Setup prompts

1. Ask me for my email address. 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.
   Show me the Terms (https://platform.experientiallabs.ai/terms) and Privacy (https://platform.experientiallabs.ai/privacy)
   links and ask whether I agree to the terms and privacy conditions.
   Wait for my affirmative answer before creating an account. Do not infer agreement.

2. Create my account instantly, no browser, no password, no code.
   POST https://pr-1992.preview.experientiallabs.ai/api/signup/instant   (no auth)
   Header: Content-Type: application/json
   Body: {"email": "<MY_EMAIL>", "agree": true}
   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-1992.preview.experientiallabs.ai/signin to get a key (don't retry with another email).
     - 403 signup_disabled | signup_domain_blocked | work_email | signup_refused
       -> the signup was refused; show me the response's
       `error` text verbatim (it says what to do) and stop.
     - 428 terms_acceptance_required -> show the policy links and ask for agreement.
     - 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-1992.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-1992.preview.experientiallabs.ai/v1/models with the key -> the models my account can call. Do NOT
   make a paid chat completion yet: follow the activation steps shown at
   overview_url first. If payment is required, I complete it myself on
   https://pr-1992.preview.experientiallabs.ai/credits. If manual review is required, help me submit an appeal and
   wait for approval; payment cannot unlock that review. 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-1992.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-1992.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-1992.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, Pro) so those calls bill my own accounts
     (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-1992.preview.experientiallabs.ai/settings; balances live at
   https://pr-1992.preview.experientiallabs.ai/credits.

Read the contract if you build further: https://pr-1992.preview.experientiallabs.ai/docs (human docs) and
https://pr-1992.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-1992.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-1992.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-1992.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-1992.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-1992.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. Name the
     model by its gateway slug exactly as GET https://api-pr-1992.preview.experientiallabs.ai/v1/models lists it (the DOT
     form, e.g. claude-fable-5.1 — Anthropic's dashed ids like claude-fable-5-1
     answer 403 model_not_granted). If the slug is not an Anthropic model, also
     export CLAUDE_CODE_MAX_CONTEXT_TOKENS=<max_input_tokens from
     GET https://api-pr-1992.preview.experientiallabs.ai/api/models/<slug>, rounded down to the nearest 50k> — Claude Code
     assumes 200k for names it does not know and compacts early. NEVER use
     context_window for that pin: on an OpenAI-family model it is a total window
     the provider counts the model's maximum output inside, so a session pinned to
     it never compacts before the provider refuses it and /compact then fails the
     same way. max_input_tokens already accounts for this per maker, so it is
     always the right pin. Warn me plainly: if a session ever shows
     "Not logged in · Please run /login", do NOT run /login (it starts Anthropic
     OAuth that overrides the gateway) — restart with --resume, and if it
     persists, my <config dir>/.claude.json remembers a "No" to the custom-API-key
     prompt under customApiKeyResponses.rejected: answer Yes or move the entry to
     approved. Images work on image-capable routes and are rejected by name on
     text-only ones; extended thinking passes through on all-Anthropic routes
     and is translated to reasoning effort elsewhere.

   - 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-1992.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-1992.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-1992.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 *_nano_usd_per_million / 1000000000) for each slug from
     GET https://api-pr-1992.preview.experientiallabs.ai/api/models/<slug> so my context window and spend display are right.

   - Hermes Agent (Nous Research):
     First prove the lane in a throwaway data dir so my real ~/.hermes (config,
     sessions, memories) stays untouched: create "$(mktemp -d)", write ONLY the
     config below plus a .env line EXPLABS_API_KEY=<my key> (chmod 600) into it,
     then run
       HERMES_HOME=<that dir> hermes -z "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
     round-trip. Then merge the same block into ~/.hermes/config.yaml (show me
     the diff before writing) and put the key line in ~/.hermes/.env:
       providers:
         explabs:
           base_url: "https://api-pr-1992.preview.experientiallabs.ai/v1"
           key_env: "EXPLABS_API_KEY"
           api_mode: chat_completions
       model:
         provider: "custom:explabs"
         default: "<slug I pick>"
     Any catalog slug works as the default, and /model custom:explabs:<slug>
     switches mid-session. Warn me plainly: Hermes' session-title side call
     sends a temperature value, so on models that pin their sampling the title
     falls back to a default — the session itself is unaffected.

   - Pi:
     First prove the lane in a throwaway home so my real ~/.pi (auth, sessions,
     model store) stays untouched: pi resolves its agent dir from HOME, so create
     "$(mktemp -d)" and copy my real ~/.pi into it (extensions, skills, and
     settings ride the test — tool schemas are where provider strictness bites,
     so a defaults-only run proves too little; if ~/.pi does not exist yet, just
     create <that dir>/.pi/agent). Then merge the block below into that copy's
     .pi/agent/models.json and run
       HOME=<that dir> EXPLABS_API_KEY=<my key> pi -p --provider explabs \
         --model "<slug I pick>" "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
     round-trip, then DELETE the throwaway home ("rm -rf <that dir>") — the copy
     carries my auth and session state and must not outlive the proof. Then
     merge the same provider into ~/.pi/agent/models.json
     (create it as {"providers": {}} if missing; show me the diff before
     writing):
       { "providers": { "explabs": {
           "baseUrl": "https://api-pr-1992.preview.experientiallabs.ai/v1",
           "api": "openai-completions",
           "apiKey": "$EXPLABS_API_KEY",
           "models": [ { "id": "<slug I pick>", "name": "<slug I pick>",
             "reasoning": true, "input": ["text", "image"],
             "contextWindow": <from GET https://api-pr-1992.preview.experientiallabs.ai/api/models/<slug>>,
             "maxTokens": <from the same> } ] } } }
     The apiKey stays the literal string "$EXPLABS_API_KEY" — pi interpolates it
     from my environment, so make sure the variable is exported where I launch
     pi and never write the raw key into the file. Set reasoning/input to the
     slug's actual catalog capabilities. Any catalog slug works; I pick models
     with --model at launch or /model in-session (models.json reloads each time
     /model opens, no restart).

   - 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-1992.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-1992.preview.experientiallabs.ai/api/models/<slug>.

   - VS Code (Copilot Chat):
     Copilot's bring-your-own-model support is VS Code core (1.122+); chat and
     agent mode need no Copilot plan. Find my VS Code user dir (macOS
     ~/Library/Application Support/Code/User, Linux ~/.config/Code/User, Windows
     %APPDATA%\Code\User) and merge this entry into chatLanguageModels.json
     there (create the file as a JSON array if missing), one models[] item per
     slug I pick:
       { "name": "Experiential Labs", "vendor": "customendpoint",
         "apiType": "chat-completions",
         "models": [ { "id": "<slug I pick>", "name": "<slug I pick>",
           "url": "https://api-pr-1992.preview.experientiallabs.ai/v1/chat/completions",
           "toolCalling": true, "vision": true,
           "modelOptions": { "temperature": null, "top_p": null } } ] }
     Set toolCalling and vision to each slug's ACTUAL capabilities from
     GET https://api-pr-1992.preview.experientiallabs.ai/api/models/<slug> (tool support and image input) — declaring a
     capability the model lacks makes Copilot send tool calls or images the
     route rejects.
     The null modelOptions are required, not decoration: null deletes the field,
     and Copilot otherwise sends temperature 0.1 and top_p 1 on every request,
     which models that pin their sampling reject with a 400 naming the
     parameter. You cannot enter my key — it lives in VS Code's encrypted secret
     storage — so print the manual step: in the Chat model picker open Manage
     Models, right-click the Experiential Labs model, choose to enter an API
     key, and paste my key (<my key>). VS Code stores it encrypted and writes
     the ${input:chat.lm.secret.*} references into the entry itself; never
     hand-write a raw key into the file.

   - 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-1992.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-1992.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-1992.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-1992.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.

Set up per-identity API keys for my Experiential Labs organization so
spend is bucketed per identity (for example "coding" vs "product") in usage.

Provisioning key: xpl_<paste-your-provisioning-key-here>
(I replace the placeholder above before sending. It is a PROVISIONING key:
it can manage this org's keys, identities, and budgets. Never print it back
to me, never write it into any file, and do not use it for inference. The
API does not stop you from doing those; these are my rules.)

Base URLs: API https://api-pr-1992.preview.experientiallabs.ai (management under /api, inference under /v1),
dashboard https://pr-1992.preview.experientiallabs.ai. Every call below sends
  Authorization: Bearer <the provisioning key>
plus Content-Type: application/json on writes. On a non-2xx read the JSON
"error" field; a body with "detail" instead is a request-shape failure and
detail[0].loc[-1] names the offending field. Then apply the Fallbacks.
What this key can call: GET /api/whoami; GET, POST /api/orgs/{org_id}/identities; PATCH /api/orgs/{org_id}/identities/{identity_id} (display_name and description only); GET, POST /api/v1/keys; GET, PATCH, DELETE /api/v1/keys/{hash}; GET, PUT /api/orgs/{org_id}/budgets; DELETE /api/orgs/{org_id}/budgets/{budget_id} (identity- and key-scope budgets this key created); GET /api/orgs/{org_id}/usage/by-identity.
Disabling an identity, model grants, org-wide budgets, the default identity's
budget, and any budget an admin set are the admin's, on https://pr-1992.preview.experientiallabs.ai/api-keys; if a
step needs one of those, ask me instead.

1. Discover the organization.
   GET https://api-pr-1992.preview.experientiallabs.ai/api/whoami -> {org_id, org_slug, org_name}. Keep org_id; every
   /api/orgs/{org_id}/... call below uses it. Then
   GET https://api-pr-1992.preview.experientiallabs.ai/api/orgs/{org_id}/identities -> {identities: [{identity_id,
   display_name, active, is_default, ...}]}. The is_default row is the org's
   own identity: leave it alone, mint no keys under it, cap nothing on it.

2. Settle the identities. If my message already names them (and any limits),
   take that as the plan and proceed without asking. Otherwise propose these
   defaults and ask me ONCE to confirm, rename, drop, or add, plus an optional
   monthly USD limit (on the identity, its key, or none) and each key's tool:
     coding   - IDE and terminal coding agents
     product  - the product's own inference traffic
     research - experiments, evals, notebooks

3. Create each identity (reuse one that exists).
   POST https://api-pr-1992.preview.experientiallabs.ai/api/orgs/{org_id}/identities
     {"display_name": "Coding", "identity_id": "coding", "description": "<one line>"}
   201 -> created. 409 (code identity_id_unavailable) -> the id already
   exists: if it is in MY list from step 1, reuse that identity; otherwise
   (ids are unique platform-wide, and only need to be unique to my tooling)
   retry ONCE with details.suggested_id from that response. identity_id
   starts with a letter, continues with lowercase letters or digits, groups
   joined by ".", "-" or "_", and never starts with "org-". If step 1 listed
   the identity with active=false, do not use it: an admin disabled it on
   purpose and only the dashboard re-enables it. Tell me and pick another.

4. Mint ONE inference key per identity.
   POST https://api-pr-1992.preview.experientiallabs.ai/api/v1/keys
     {"name": "<identity>-<tool>", "identity_id": "<identity_id>"}
   200 -> {data: {hash, name, identity_id, ...}, key: "xpl_..."}. The plaintext
   appears exactly once; hold it only until step 6. Never set "provisioning":
   true on these keys (the API would allow it; I do not). Check
   data.identity_id matches. An optional DAILY USD cap: "limit": 5 in the body.

5. Budgets, only where I asked for one. Monthly, recurring, in nano-USD
   ($1 = 1000000000). 0 is a HARD $0 cap, never "no cap"; remove one with
   DELETE https://api-pr-1992.preview.experientiallabs.ai/api/orgs/{org_id}/budgets/{budget_id}. Replace or delete only
   budgets this key created (an admin's row is 403). Never the default identity's.
   PUT https://api-pr-1992.preview.experientiallabs.ai/api/orgs/{org_id}/budgets
     {"period": "*", "scope_kind": "identity", "identity_id": "coding",
      "limit_nano_usd": 50000000000}          # $50/month for the identity
     {"period": "*", "scope_kind": "key", "api_key_id": "<data.hash>",
      "limit_nano_usd": 20000000000}          # $20/month for one key
   Only those two scope kinds are this key's to set. Read back with
   the calendar month, never "*": GET https://api-pr-1992.preview.experientiallabs.ai/api/orgs/{org_id}/budgets?period=YYYY-MM

6. Hand me one table: identity -> key name -> where the key goes. Print each
   new key exactly once, in that table, and nowhere else. Never commit a key;
   prefer the OS keychain or a .env file that is gitignored. Per tool:
     Claude Code:   export ANTHROPIC_BASE_URL="https://api-pr-1992.preview.experientiallabs.ai"      (no /v1 suffix)
                    export ANTHROPIC_API_KEY="<key>"
                    export ANTHROPIC_MODEL="<slug from GET https://api-pr-1992.preview.experientiallabs.ai/v1/models>"
     Codex, Cline, Cursor, the OpenAI SDK, any OpenAI-compatible tool:
                    export OPENAI_BASE_URL="https://api-pr-1992.preview.experientiallabs.ai/v1"
                    export OPENAI_API_KEY="<key>"
     OpenCode:      a provider in opencode.json with
                    "npm": "@ai-sdk/openai-compatible" and
                    "options": {"baseURL": "https://api-pr-1992.preview.experientiallabs.ai/v1", "apiKey": "{env:OPENAI_API_KEY}"}
     A server:      the same OPENAI_* pair in its secret store. Per-tool
                    steps: https://pr-1992.preview.experientiallabs.ai/docs/coding-agents.

7. Verify every key with one request and show me where the spend lands.
   GET https://api-pr-1992.preview.experientiallabs.ai/v1/models (bearer required) for a slug, then
   POST https://api-pr-1992.preview.experientiallabs.ai/v1/chat/completions with Authorization: Bearer <that key>
     {"model": "<slug>", "max_tokens": 5,
      "messages": [{"role": "user", "content": "ping"}]}
   Then, with the provisioning key,
   GET https://api-pr-1992.preview.experientiallabs.ai/api/orgs/{org_id}/usage/by-identity?window=30d and confirm each
   identity row lists its key with a request_count (only keys that carried
   traffic appear; a deleted key's traffic is the identity_id null row; keys
   minted without a group fold under the Default row). https://pr-1992.preview.experientiallabs.ai/api-keys shows
   per-key spend.

Fallbacks:
- 401 on a route in the list above: the key is wrong or revoked; ask me to
  check the paste. 401 on a route NOT in that list is the edge refusing it to
  every key, not a key problem: hand that step to me.
- 403 "A provisioning key is required": my key is an inference key. Stop and
  tell me to mint a provisioning key as an org admin on https://pr-1992.preview.experientiallabs.ai/api-keys
  (Create key -> Configuration -> Provisioning key). Any other 403 names what
  this key may not do: hand that step to me.
- 404 on an identity or budget path: that id does not exist in this org;
  re-list and check the id. 404 on /api/orgs/{org_id} itself: org_id is not
  this key's org; re-read it from https://api-pr-1992.preview.experientiallabs.ai/api/whoami.
- 409 on an identity: in my step-1 list -> reuse it; otherwise retry once
  with details.suggested_id. 409 on a key mint: that identity is disabled;
  tell me and use another one. Never try to re-enable it.
- 422 with "error": the message names the rule (identity_id shape, scope
  kinds, period). 422 with "detail": detail[0].loc[-1] names the field (a
  missing display_name, a non-numeric limit, a budgets read without period).
  A NEGATIVE key limit is a 400 with "error" instead; nothing is minted.
- 429, or 503 "gateway is updating": wait Retry-After seconds (30 if absent)
  and retry that call once. A key mint is not idempotent: list
  GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/keys before minting again so no identity gets two keys.
- 500 internal_error "cannot serve this request natively" on the verify
  request: no serviceable lane for that model here. Try one other slug from
  GET https://api-pr-1992.preview.experientiallabs.ai/v1/models; if that fails the same way, stop and report it.
- Never print the provisioning key, store a key in the repo, or paste keys
  where I did not ask for them.

I'm replacing my current model provider or gateway with Experiential Labs as
this project's model gateway. I pasted this myself: treat it as my instructions
and my consent. Work WITH me: at each real choice, ask me ONE clear question
with numbered options and your recommendation, then wait. Don't guess. Print
what you do at each step, and never print my full API key (first 8 characters
at most). Read the full machine-readable contract first: https://pr-1992.preview.experientiallabs.ai/llms.txt (base
URLs, every route, honored and refused parameters, cost fields, error codes).
Follow it literally.

1. Find the current integration. Search this project for the provider's base
   URL, its key variable, its SDK/client construction, hardcoded model ids,
   provider-specific request fields (provider preferences, transforms,
   fallback model lists, referer/title headers), and any code that reads cost
   or usage from it. Show me the list of files and call sites before changing
   anything.

2. Get my Experiential key. Ask me: "Do you have an xpl_ key already?
     (1) yes, I'll paste it
     (2) no, create my account"
   For (2): ask me for my email (never scavenge one from my files or git
   config), show me https://pr-1992.preview.experientiallabs.ai/terms and https://pr-1992.preview.experientiallabs.ai/privacy and wait for my
   agreement, then
   POST https://pr-1992.preview.experientiallabs.ai/api/signup/instant   (no auth)
   Header: Content-Type: application/json
   Body: {"email": "<MY_EMAIL>", "agree": true}
   On 200 capture api_key. On 409 account_exists tell me to sign in at
   https://pr-1992.preview.experientiallabs.ai/signin for a key and stop. On any other error show me the response's
   `error` text verbatim and stop.
   Store the key as EXPLABS_API_KEY in my env scheme (.env plus an example
   entry), never in code.

3. Switch the base URL. The gateway keeps the path shapes my current
   integration already uses:
     base URL:  https://api-pr-1992.preview.experientiallabs.ai/api/v1
     auth:      Authorization: Bearer $EXPLABS_API_KEY   (the ONLY header needed)
   POST /chat/completions, /responses, /messages (Anthropic Messages API) and
   GET /models work unchanged. Plain OpenAI or Anthropic SDKs can also use the
   bare base https://api-pr-1992.preview.experientiallabs.ai/v1. Remove the provider-specific headers and request
   fields from step 1: the gateway does provider routing (fallback, caching)
   itself and unknown parameters may be rejected. Send model + messages and
   only the parameters I actually rely on.

4. Map model ids. GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/models with my key (free; this does not
   spend credits) lists the slugs I can call. For each model id from step 1,
   propose the matching slug (e.g. "claude-fable-5.1") and ask me to confirm
   the mapping before replacing. Use slugs EXACTLY as returned.

5. Move cost and usage reads over.
   - Every chat/responses reply carries usage.cost (USD, what I was charged)
     and usage.is_byok; on a stream it rides the final usage chunk. No flag
     needed. Exception: a request sent with Idempotency-Key carries no
     usage.cost at all (original or replay), so read the field as optional.
   - One request: read the x-request-id response header and call
     GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/generation?id=<that id>.
   - Balance: GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/credits. Recent activity:
     GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/activity.
   - Billing feed: GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/usage is the settled per-request export
     (cost_usd, estimated_cost_usd, real_cost_usd, tokens, attribution_label,
     api_key_id), newest first inside a lookback window (24h|7d|30d); its
     next_cursor pages OLDER within one call and is not a resume checkpoint.
     Each run scans from the top and dedupes on the row id.
   - If I rebill my own customers, pass their stable id as safety_identifier
     (alias: user) on every request; it comes back as attribution_label.
   Replace my old provider's cost/usage code with these; show me the diff
   first.

6. Key management (only if my code creates or rotates keys programmatically).
   https://api-pr-1992.preview.experientiallabs.ai/api/v1/keys (GET/POST/PATCH/DELETE) requires a PROVISIONING key: an
   xpl_ key minted with "provisioning": true. The first one is created from
   the dashboard at https://pr-1992.preview.experientiallabs.ai/api-keys (org admin, "Provisioning key" option).
   Tell me to mint it and paste it as a separate server-side secret; never use
   it for inference traffic.

7. Verify. Make ONE minimal test call (model + messages only, no sampling
   parameters) with a free promotional model from the /models list, or one I
   name. Report the model, that it succeeded, and its usage.cost. If it fails
   with a credits or activation error, tell me to finish activation at https://pr-1992.preview.experientiallabs.ai
   and stop; do not retry with another provider. Then run the project's
   existing tests.

8. Report back: every file changed, the model-id mapping, what happened to the
   old provider key (tell me to revoke it at the old provider; don't delete it
   yourself), and the test call result. Human docs if you need more:
   https://pr-1992.preview.experientiallabs.ai/docs/integrate.

I'm integrating Experiential Labs into this product as its model gateway: my
product calls models through it and meters or rebills my own end-users. I
pasted this myself: treat it as my instructions and my consent. Work WITH me:
at each real choice, ask me ONE clear question with numbered options and your
recommendation, then wait. Don't guess. Print what you do at each step, and
never print my full API key (first 8 characters at most). Read the full
machine-readable contract first: https://pr-1992.preview.experientiallabs.ai/llms.txt (base URLs, every route,
honored and refused parameters, cost fields, error codes). Follow it literally.

1. Get my Experiential key. Ask me: "Do you have an xpl_ key already?
     (1) yes, I'll paste it
     (2) no, create my account"
   For (2): ask me for my email (never scavenge one from my files or git
   config), show me https://pr-1992.preview.experientiallabs.ai/terms and https://pr-1992.preview.experientiallabs.ai/privacy and wait for my
   agreement, then
   POST https://pr-1992.preview.experientiallabs.ai/api/signup/instant   (no auth)
   Header: Content-Type: application/json
   Body: {"email": "<MY_EMAIL>", "agree": true}
   On 200 capture api_key. On 409 account_exists tell me to sign in at
   https://pr-1992.preview.experientiallabs.ai/signin for a key and stop. On any other error show me the response's
   `error` text verbatim and stop.
   Store the key as EXPLABS_API_KEY in my env scheme (.env plus an example
   entry), never in code.

2. Wire the client. Ask me where (options + your recommendation, based on what
   you see in this project), then wait. Configure an OpenAI-compatible or
   Anthropic client with:
     base URL:  https://api-pr-1992.preview.experientiallabs.ai/api/v1   (inference, model discovery, cost, and
                account routes under one base; plain OpenAI / Anthropic SDKs
                may also use https://api-pr-1992.preview.experientiallabs.ai/v1)
     auth:      Authorization: Bearer $EXPLABS_API_KEY   (the ONLY header needed)
   POST /chat/completions, /responses, or /messages (Anthropic Messages API).
   Name models by slug EXACTLY as GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/models returns them
   (free; this does not spend credits). Send model + messages and only the
   parameters I actually rely on; unknown parameters may be rejected.

3. Attribute every request to my end-customer. Pass their stable id as
   safety_identifier (alias: user) on every request. It comes back as
   attribution_label on the usage export, so I can group cost and tokens by
   my own customer id with ONE key. Ask me what my customer id looks like and
   wire it through from where my code knows the customer.

4. Read cost.
   - Inline: every chat/responses reply carries usage.cost (USD, what I was
     charged) and usage.is_byok; on a stream it rides the final usage chunk.
     No flag needed, but a request sent with Idempotency-Key carries no
     usage.cost at all (original or replay), so read it as optional. Show it
     in my product where it helps; do not treat it as the billing record.
   - One request: read the x-request-id response header and call
     GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/generation?id=<that id>.
   - Balance: GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/credits (data.total_credits - data.total_usage).

5. Build the billing sync on the settled export. Ask me which billing system I
   use (Metronome, Orb, Stripe metered billing, my own tables, or none yet),
   then write a scheduled job that:
   - reads GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/usage?limit=1000 (settled rows, newest first
     inside a lookback window: window=24h|7d|30d, default 7d; filterable by
     attribution_label, model, api_key_id, status). next_cursor
     ({cursor_ts, cursor_id, cursor_after}, passed back as query params)
     pages OLDER within this one call and is NOT a checkpoint to resume from
     next run: each run starts at the top, follows next_cursor until a whole
     page is older than the last successful run's start time minus a grace
     period covering my longest request, and dedupes on the row id. Schedule
     it at least daily; rows older than 30 days are no longer exportable.
   - lands each row in a local outbox table keyed on the row id (insert, on
     conflict do nothing) in one local transaction, then in a separate
     delivery step pushes unsent rows to the billing system and marks them
     sent (an external HTTP write cannot share my database transaction; the
     outbox makes a crash between the two safe to replay),
   - sends one usage event per row: customer from attribution_label,
     transaction_id / idempotency key = the row id, timestamp = created_at,
     quantity = the cost column I choose (below) plus token counts if I meter
     on tokens; the margin is a rate in the billing system, not in this job.
   Cost columns: cost_usd is the platform credits charged; estimated_cost_usd
   is the attributed value of a BYOK row (served on my own provider key) at
   catalog list rates, an estimate and never the provider's invoice;
   real_cost_usd is the two added together. Ask me whether to bill
   real_cost_usd (accepting the BYOK estimate) or cost_usd plus tokens on
   BYOK rows. pricing_known false means unpriced (cost 0), not free.

6. Key-per-customer (optional; ask me). If I want each customer isolated to
   their own key with independent revocation and a daily USD cap, that needs
   a PROVISIONING key: an xpl_ key minted with "provisioning": true. The
   first one comes from the dashboard at https://pr-1992.preview.experientiallabs.ai/api-keys (org admin,
   "Provisioning key" option); keep it server-side and never use it for
   inference. With it: POST https://api-pr-1992.preview.experientiallabs.ai/api/v1/keys {name, limit, provisioning}
   returns the plaintext key exactly once; GET/PATCH/DELETE
   https://api-pr-1992.preview.experientiallabs.ai/api/v1/keys/{hash} list, update (disabled:true revokes), and revoke.
   A normal inference key gets 403 on every /keys route.

7. Verify. Make ONE minimal test call (model + messages only) with a free
   promotional model from the /models list, or one I name, carrying a test
   safety_identifier. Report the model, that it succeeded, and its usage.cost;
   then confirm the row shows up on GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/usage with that
   attribution_label. If the call fails with a credits or activation error,
   tell me to finish activation at https://pr-1992.preview.experientiallabs.ai and stop. Then run the project's
   existing tests.

8. Report back: every file changed, where the key lives, how customer
   attribution flows, and the billing job's schedule and cursor storage.
   Human docs if you need more: https://pr-1992.preview.experientiallabs.ai/docs/integrate, https://pr-1992.preview.experientiallabs.ai/docs/cost-api,
   and https://pr-1992.preview.experientiallabs.ai/docs/account-api.

I'm moving this project off OpenRouter and onto the Experiential Labs gateway.
I pasted this myself: treat it as my instructions and my consent. Work through
it end to end; stop and ask me ONE numbered question only where this prompt
says to. Print what you change at each step. Never print my full API key
(first 8 characters at most). My Experiential key is: xpl_...
(if that still reads "xpl_..." I have not filled it in: ask me for it, or tell
me to mint one at https://pr-1992.preview.experientiallabs.ai/api-keys, then continue).

1. Find every place this project talks to OpenRouter. Search for:
   - the base URL https://openrouter.ai/api/v1 (openrouter.ai anywhere), env
     vars OPENROUTER_API_KEY / OPENROUTER_BASE_URL, and sk-or-v1- keys in
     .env*, docker-compose, Makefiles, CI config, and secret stores,
   - clients pointed at it: openai or Anthropic SDKs (TS / Python / Go),
     ruby-openai (uri_base:), Go net/http, fetch / curl / any HTTP client,
     Vercel AI SDK @openrouter/ai-sdk-provider, LangChain, LiteLLM openrouter/ ids,
   - coding-agent configs: opencode.json provider blocks, Claude Code
     ANTHROPIC_BASE_URL in .claude/settings*.json or shell exports, Cline /
     Continue / Cursor "OpenAI Compatible" settings, Codex config.toml,
   - hardcoded vendor/model ids (openai/gpt-6-astra, openrouter/auto, ...),
     OpenRouter-only fields (provider, transforms, route, models, plugins,
     usage), HTTP-Referer / X-Title, previous_response_id, and reads of
     /generation, /credits, /auth/key, /models/user, /activity, usage.cost.
   List the files and call sites before changing anything.

2. Substitute the base URL and the key. The gateway keeps OpenRouter's paths:
     https://openrouter.ai/api/v1  ->  https://api-pr-1992.preview.experientiallabs.ai/api/v1
     Authorization: Bearer $EXPLABS_API_KEY   (the ONLY header needed)
   Store my key as EXPLABS_API_KEY in this project's env scheme (.env plus the
   example file entry), never in code; point every OpenAI-compatible client at
   the new base (a plain OpenAI SDK may also use https://api-pr-1992.preview.experientiallabs.ai/v1) and
   REPLACE URL variables such as OPENROUTER_BASE_URL with it. An Anthropic SDK
   appends /v1/messages itself: its base is the bare origin https://api-pr-1992.preview.experientiallabs.ai
   (never .../v1, which doubles to /v1/v1/messages). Do NOT
   delete OPENROUTER_API_KEY or the OpenRouter key from .env, secret stores or
   CI: stop reading it, leave it in place; I revoke it at openrouter.ai/keys.
   A key COMMITTED in a config file (ANTHROPIC_AUTH_TOKEN in a checked-in
   .claude/settings.json) is already leaked: remove it there, never send it on.
   Coding agents: Claude Code uses ANTHROPIC_BASE_URL="https://api-pr-1992.preview.experientiallabs.ai"
   (no /v1); the key rides ANTHROPIC_API_KEY (never ANTHROPIC_AUTH_TOKEN) via
   a shell export, the gitignored .claude/settings.local.json, or an
   apiKeyHelper reading .env, never the committed .claude/settings.json; remap
   EVERY model variable (ANTHROPIC_MODEL, ANTHROPIC_SMALL_FAST_MODEL,
   ANTHROPIC_DEFAULT_*_MODEL) to slugs or a background role keeps calling an
   expensive model. OpenCode, Cline, Continue, Cursor and Codex take the
   OpenAI base https://api-pr-1992.preview.experientiallabs.ai/v1.

3. Map model ids. Call GET https://api-pr-1992.preview.experientiallabs.ai/api/v1/models with my
   key (free, spends no credits). EVERY entry carries canonical_slug, the
   plain slug the gateway serves; ids are usually vendor/slug (vendor/slug:free
   for a free lane), sometimes a bare slug (gpt-6-astra, grok-4); ~vendor/x-latest
   ids are rolling aliases, for projects that used OpenRouter's :latest ids.
   For each OpenRouter id from step 1: strip any :nitro, :floor, :online,
   :thinking, :extended, :beta or :exacto suffix (those variants do not exist
   here; only :free does), then match canonical_slug == the part after the
   vendor's slash (openai/gpt-6-astra -> gpt-6-astra, anthropic/claude-sonnet-5
   -> claude-sonnet-5, deepseek/deepseek-v4-flash -> deepseek-v4-flash).
   No match: look for the same model under a slightly different spelling and
   use ONE obvious candidate, noted in the report. openrouter/auto and every
   id still unmapped: ask me one question listing each with your best
   candidates from the list, then wait. Never guess a model I did not pick.
   Use canonical_slug EXACTLY as returned; a vendor/slug id works verbatim
   ONLY when it is in the list (x-ai/grok-4 for the bare grok-4 answers 403
   model_not_granted: that means "use the canonical_slug", not an entitlement
   problem). LiteLLM: model "openai/<slug>" (replace the "openrouter/" prefix)
   with api_base https://api-pr-1992.preview.experientiallabs.ai/api/v1 and api_key from the new var.

4. Keep the request shapes (OpenAI Chat Completions and Responses bodies, SSE
   streaming, tool calling, json_schema, response shapes). Strip EVERY
   OpenRouter-only field BEFORE the first call: each one left in is either
   silently ignored or its own 400 unsupported_parameter naming it in "param".
   - usage: {"include": true} (a guaranteed 400 today); for a stream send
     stream_options: {"include_usage": true} instead (non-streams carry usage).
   - provider (order, allow_fallbacks, ignore, quantizations, sort, ...):
     accepted and silently ignored (not disclosed); the gateway routes and
     fails over itself. The one honored key is "provider": {"zdr": true}, a
     per-request zero-data-retention demand; keep exactly that if I used it.
   - transforms, route, models (fallback list: use its first model), plugins.
   - HTTP-Referer / X-Title headers: harmless, not shown; attribute via safety_identifier.
   Vercel AI SDK: replace @openrouter/ai-sdk-provider with @ai-sdk/openai
   (createOpenAI({ baseURL, apiKey })) or @ai-sdk/openai-compatible.
   OpenRouter's "reasoning": {"effort"} is translated to reasoning_effort by
   the gateway (rewriting it is optional; a route with no reasoning drops it).
   Translated, dropped or adjusted fields are usually listed in the reply's
   x-experiential-ignored-parameters JSON body field (not a header): informational.
   Anthropic-shaped traffic through OpenRouter (an Anthropic SDK, Claude Code)
   moves to the native Messages API, POST https://api-pr-1992.preview.experientiallabs.ai/api/v1/messages
   (SDK base: the bare origin, step 2), same key; no Idempotency-Key there.
   Responses API previous_response_id: continuation resolves ONLY while my
   org's capture_prompt_content is on and within the retention window; with
   capture off the second turn 400s previous_response_not_found. If the
   project chains turns that way, read
     GET https://api-pr-1992.preview.experientiallabs.ai/api/orgs/<org_id>/telemetry-settings (org_id: /api/whoami);
   if off, ask me ONE question: turn it on (PUT the same route,
   {"capture_prompt_content": true}; it stores my prompts with Experiential)
   or rewrite the chain to resend the full conversation each turn.

5. Move cost reads. Every chat / responses reply carries usage.cost (USD, what
   I was charged) and usage.is_byok; on a stream it rides the final usage
   chunk (step 4's stream_options). A request sent with Idempotency-Key
   carries no usage.cost at all, so read the field as optional. Same key on
   all of these, under https://api-pr-1992.preview.experientiallabs.ai/api/v1:
     GET /generation?id=<the x-request-id response header>   one request
     GET /usage     settled per-request rows (api_key_id, cost) for billing
     GET /credits   balance      GET /key   key info (OpenRouter's /auth/key)
     GET /activity  per-day rollup (not per request)
   OpenRouter's /models/user has no equivalent: use /models. /usage is paginated
   (50 rows + next_cursor) and, like /activity, ORG-wide: filter ?api_key_id=<my
   key's id, on every row> and match my x-request-id, or use /generation?id=.

6. My own provider keys (BYOK). If step 1 found provider keys I routed through
   OpenRouter (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI, XAI, DEEPSEEK, AZURE,
   AWS/Bedrock, Fireworks, ...), do not drop them silently: ask me whether to
   connect them so that traffic bills to my own accounts with no markup:
     GET https://api-pr-1992.preview.experientiallabs.ai/api/whoami   -> org_id
     PUT https://api-pr-1992.preview.experientiallabs.ai/api/orgs/<org_id>/provider-connections/<provider>
         Content-Type: application/json   {"secret": "<that provider key>"}
     (provider: openai, anthropic, gemini, xai, deepseek, or any other whose
     credential is ONE string; never my OpenRouter key: I am leaving OpenRouter.
     azure_openai, bedrock, fireworks, vertex and modal need structured config
     or a token pair: connect those at https://pr-1992.preview.experientiallabs.ai/settings instead).
   Read check.status from the response and tell me it; if not "valid", tell
   me check.status_detail.remediation and stop. A 402 pro_required means a
   FIRST connection needs the Pro plan (https://pr-1992.preview.experientiallabs.ai/credits); an org
   already holding one keeps connecting. Never echo a key.

7. Verify. Make ONE minimal call (model + messages, a small max_tokens) with
   the CHEAPEST mapped slug: a reasoning model can cost cents even for a
   smoke, and an empty pricing object in the listing means unknown: read
   GET https://api-pr-1992.preview.experientiallabs.ai/api/models/<slug>, and if that 404s (an alias)
   price the model it resolves to (its canonical_slug) or skip it and smoke a
   priced slug. Stream if the project streams (add stream_options:
   {"include_usage": true} so the final chunk carries usage.cost); if the
   project chains previous_response_id, verify a TWO-turn continuation, not a
   single call. Report the model, that it succeeded, and its usage.cost, or
   read the cost from GET /api/v1/generation?id=<x-request-id>, which works
   either way; then confirm the request's row on GET /api/v1/usage by that
   x-request-id (I can also see it at https://pr-1992.preview.experientiallabs.ai/logs). On a credits
   or activation error, tell me to finish activation at https://pr-1992.preview.experientiallabs.ai
   and stop; do not retry against OpenRouter. Then run the project's tests.

8. Report back: every file changed; the model-id mapping and the ids I still
   need to decide; the OpenRouter-only fields removed; where EXPLABS_API_KEY
   lives; that the OpenRouter key stays in place for me to revoke; the
   verification result. Full contract: https://pr-1992.preview.experientiallabs.ai/llms.txt; human
   docs: https://pr-1992.preview.experientiallabs.ai/docs/integrate.