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-683.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-683.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-683.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-683.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. Here's what I want
you to do.

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-683.preview.experientiallabs.ai/settings/api-keys>

The core task is ONE thing: point an OpenAI-compatible client at my gateway
with this key and make one successful test chat completion. Do it start to
finish on your own — do NOT stop to ask me questions. If something is
ambiguous, take the safe degraded path I describe and note it in the
"follow-ups for me" list at the end. Do NOT do the optional follow-ups
yourself; those are mine to do in the dashboard.

1. Wire a client to the gateway. base_url = https://api-pr-683.preview.experientiallabs.ai/v1, api key =
   EXPLABS_API_KEY (one header: Authorization: Bearer <key>). The API is
   OpenAI-compatible; nothing else changes.
   - If this working directory is clearly ONE project with an existing
     OpenAI client, wire that: set its base_url and key, put the key in the
     project's env scheme (.env plus an example entry), never in code. Show
     me the change first.
   - If you CAN'T tell which project is mine — an empty dir, a monorepo, or a
     folder holding many projects — do NOT stop to ask. Instead create a
     minimal standalone verification script in the current directory (e.g.
     explabs_smoke.py or explabs_smoke.mjs) that reads EXPLABS_API_KEY from
     the env and does the test call in step 2, and add "wire my specific
     project's client" to the follow-ups list at the end.

2. Make the test call. GET https://api-pr-683.preview.experientiallabs.ai/v1/models with the key as a bearer
   token and use model ids EXACTLY as returned. Then send ONE minimal chat
   completion (a few tokens) to the smallest Qwen in that list (qwen3.5-9b at
   launch). Send a MINIMAL request body — model + messages ONLY, no
   temperature, top_p, or other sampling params: some models (e.g. Claude 5)
   reject those and the call comes back as all_routes_failed (502). If you
   want to add options later, check the model's supported params in
   https://pr-683.preview.experientiallabs.ai/llms.txt first. This call runs on Experiential's
   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.
   If you truly can't run it (no network): still write the script, print the
   exact curl I can copy from https://pr-683.preview.experientiallabs.ai/docs, and note it in the
   follow-ups.

3. Report back, then hand me the follow-ups. Tell me: what you changed (or the
   standalone script you created), and the test call's model, that it
   succeeded, and its cost. Then list "follow-ups for me" — anything you
   deferred above, PLUS these optional steps, which are MINE to do in the
   dashboard (do NOT attempt them yourself, and don't block on them):
   - Wire my specific project's client, if you only created a standalone
     script (skip this line if you already wired a real project).
   - Connect my own provider keys (BYOK) for free pass-through. I'll add them
     at https://pr-683.preview.experientiallabs.ai/settings/integrations — verified on save, confirmed per
     key by prefix, landing in my own gateway account and nowhere else.
   - Import my existing Claude Code / Codex usage history (metadata only) so
     my dashboard opens with real spend, from https://pr-683.preview.experientiallabs.ai/settings.
   - Review all my balances and spend — platform-funded credits and free
     pass-through both — at https://pr-683.preview.experientiallabs.ai/credits, summarized on my Overview.

Read the contract if you build further: https://pr-683.preview.experientiallabs.ai/docs (human docs) and
https://pr-683.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-683.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-683.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-683.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. 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-683.preview.experientiallabs.ai"        # no /v1 suffix
       export ANTHROPIC_AUTH_TOKEN="<my key>"
       export ANTHROPIC_MODEL="<slug I pick>"
     Then tell me to restart you from a shell with those set. Warn me plainly:
     extended thinking is unavailable through the gateway and image pastes are
     rejected (the lane is text-only).

   - Conductor:
     Print these for me to put in Settings -> Environment (Claude Code section),
     or write them to this repo's .conductor/settings.local.toml under
     [environment_variables] if I prefer (make sure that file is
     git-ignored before writing my key into it):
       ANTHROPIC_BASE_URL = "https://api-pr-683.preview.experientiallabs.ai"
       ANTHROPIC_AUTH_TOKEN = "<my key>"
       ANTHROPIC_API_KEY = ""
     The empty ANTHROPIC_API_KEY is required: it stops Claude Code from trying to
     authenticate with Anthropic directly.

   - OpenAI Codex CLI:
     Add to ~/.codex/config.toml (create it if missing, show me the diff before
     writing):
       model = "<slug I pick>"
       model_provider = "explabs"
       [model_providers.explabs]
       name = "Experiential Labs"
       base_url = "https://api-pr-683.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.

   - 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-683.preview.experientiallabs.ai/v1", "apiKey": "{env:EXPLABS_API_KEY}"},
        "models": {"<slug>": {"name": "<slug>"}}}}
     Fill limit.context/limit.output for each slug from
     GET https://api-pr-683.preview.experientiallabs.ai/api/models/<slug> so my context window is 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-683.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-683.preview.experientiallabs.ai/api/models/<slug>.

   - Any other OpenAI-compatible tool:
     Export OPENAI_BASE_URL="https://api-pr-683.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-683.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-683.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.

I pasted this into you myself — please create an Experiential Labs account for
me and then pull my existing LLM traces onto the platform as telemetry. This is
my consent to create the account under my identity (using the email I give you
when you ask), to read my own trace files, and to use the observability
credential I give you. No browser step is needed to start — my account is
created instantly from my email; I only verify that email later to unlock my
credits, and I don't need to for my traces to land.

This uploads my existing traces so I can see them as telemetry on the platform.

Do it in this order. Print what you're doing at each step. If you lack a
capability (no network, no file access) or get stuck, stop and tell me exactly
what to do manually. Never invent an email, an API key, a credential, or a file
path — if you don't have one, ask me.

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

Now bring my traces in as telemetry. Use EXPLABS_API_KEY (the xpl_ key from
step 2) as the bearer token on every call below. org_id is from step 2.

5. Interview me: where do my LLM traces live? Ask me one clear question and wait
   for my answer. Map my answer to exactly one path:
   - A supported observability provider or database Platform can pull directly
     (transport_kind one of: braintrust, langsmith, langfuse, posthog, mastra, postgres) -> go to step 6 (live pull).
   - An exported trace FILE on disk — a raw OpenTelemetry/OTLP export, an
     Arize/Phoenix export, or any of these upload formats
     (source_kind one of: otlp, otel-genai, phoenix, braintrust, langfuse, langsmith, mastra, posthog, chat-json) -> go to step 7 (file upload).
   If I'm on Arize or Phoenix, there's no live pull yet: ask me to export my
   traces to a file and take the upload path with source_kind "phoenix" (or
   "otlp" for a raw OpenTelemetry export). If I name a provider that isn't in
   either list, tell me and offer the file-upload path. Only follow the ONE
   path that matches my answer.

6. Live pull path — connect the provider and pull. Ask me for the credential
   for the provider I named (for Braintrust an API key; for LangSmith/Langfuse
   their API key; for a Postgres database a DSN), plus the small bits of config
   that provider needs (e.g. Braintrust: the project name; LangSmith/Langfuse:
   optionally the project/host; Postgres: the table). Then:
   POST https://api-pr-683.preview.experientiallabs.ai/api/orgs/<org_id>/telemetry/traces/pull
   Header: Authorization: Bearer $EXPLABS_API_KEY, Content-Type: application/json
   Body: {"transport_kind": "<one of braintrust, langsmith, langfuse, posthog, mastra, postgres>",
          "source_kind": "<the matching format, e.g. braintrust>",
          "source_label": "<a short label, NOT a path, e.g. braintrust-prod>",
          "credential": "<the secret you asked me for>",
          "config": {"project": "<my project>"}}
   The credential is used once to pull and is not echoed back. On 201 the
   response is {"ingest_id", "trace_count", "byte_size", "sha256", ...} —
   capture trace_count and show it to me. A 400 means bad credentials or config
   (tell me exactly what it said); 429 means the provider rate-limited us (wait
   and retry). Then go to step 8.
   Example (Braintrust):
     curl -sS -X POST https://api-pr-683.preview.experientiallabs.ai/api/orgs/<org_id>/telemetry/traces/pull \
       -H "Authorization: Bearer $EXPLABS_API_KEY" \
       -H "Content-Type: application/json" \
       -d '{"transport_kind":"braintrust","source_kind":"braintrust",
            "source_label":"braintrust-prod","credential":"<my braintrust key>",
            "config":{"project":"<my braintrust project>"}}'

7. File upload path — find my trace export and upload it. I'm authorizing you to
   look for my own trace exports: search the current project, ./traces, ./logs,
   ./data, and my common cache/config paths for JSON or JSONL files that hold
   LLM/agent spans or runs (names like traces.jsonl, *.otel.jsonl, spans.json,
   otlp*.json). Show me the candidate files (path + size) and which format each
   looks like before you upload anything, and map each to ONE source_kind from:
   otlp, otel-genai, phoenix, braintrust, langfuse, langsmith, mastra, posthog, chat-json
   (raw OpenTelemetry GenAI spans -> otel-genai; a raw OTLP export -> otlp; an
   Arize/Phoenix export -> phoenix; a vendor export -> its own name; a plain
   chat transcript -> chat-json). The file must be UTF-8 JSON or JSONL and at
   most 50 MB. Then:
   POST https://api-pr-683.preview.experientiallabs.ai/api/orgs/<org_id>/telemetry/traces/upload
   This is a multipart/form-data upload with three fields:
     source_kind  = the format you chose
     source_label = a short label (NOT a file path), e.g. "prod-otel-august"
     file         = the trace file itself
   On 201 the response is {"ingest_id", "trace_count", "byte_size", "sha256"} —
   capture trace_count and show it to me. A 422 means the bytes or label failed
   validation (not JSON/JSONL, empty, or a path-like label) — tell me what it
   said. Then go to step 8.
   Example:
     curl -sS -X POST https://api-pr-683.preview.experientiallabs.ai/api/orgs/<org_id>/telemetry/traces/upload \
       -H "Authorization: Bearer $EXPLABS_API_KEY" \
       -F source_kind=otlp \
       -F source_label=prod-otel-august \
       -F file=@<path to my trace file>

8. Verify the traces landed as telemetry.
   GET https://api-pr-683.preview.experientiallabs.ai/api/orgs/<org_id>/telemetry/traces
   Header: Authorization: Bearer $EXPLABS_API_KEY
   -> 200 with {"traces": [...], "total_ingests", "total_traces"}. Confirm
   total_traces is greater than zero and matches the trace_count you captured,
   and that my ingest is in the list. Tell me the number.

When you're done, report back to me: my org_id, whether you pulled live or
uploaded a file (and from which provider/format), the ingest_id and its
trace_count, and the total_traces the verify read returned. My traces are now
telemetry on the platform. I can see them in my dashboard at https://pr-683.preview.experientiallabs.ai/telemetry,
and the machine-readable contract is https://pr-683.preview.experientiallabs.ai/llms.txt.

One last thing to tell me, then you're done: check my email inbox for a message
from Experiential Labs and click the verification link (or enter the code at
https://pr-683.preview.experientiallabs.ai/signin) to confirm my email. That's the ONLY thing left for me to do, and
it just unlocks my credits for paid model calls — my traces are already live and
don't need it. Until I verify, credit-drawing model calls are refused with
"insufficient_quota"; using my own provider keys (BYOK) is unaffected.