runpeek 0.1.0a1__tar.gz

runpeek-0.1.0a1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

runpeek-0.1.0a1/NOTICE

@@ -0,0 +1,22 @@
+RunPeek by NemulAI
+Copyright 2026 NemulAI
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Third-party components
+----------------------
+RunPeek's runtime has no third-party dependencies. The development extras
+(openai, httpx, pytest, ruff, mypy) are used only for tests and the offline
+example and are not redistributed with this package. The shipped rate cards
+contain publicly published list prices transcribed from the providers'
+pricing pages; they are data, not code, and carry the retrieval date.

runpeek-0.1.0a1/PKG-INFO

@@ -0,0 +1,349 @@
+Metadata-Version: 2.4
+Name: runpeek
+Version: 0.1.0a1
+Summary: RunPeek by NemulAI — see where your AI spends time and tokens. Local-first observability for supported AI applications and Claude Code sessions.
+Author: NemulAI
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AgentMulder404/runpeek
+Project-URL: Changelog, https://github.com/AgentMulder404/runpeek/blob/main/CHANGELOG.md
+Project-URL: Security, https://github.com/AgentMulder404/runpeek/blob/main/SECURITY.md
+Keywords: observability,llm,openai,claude-code,tokens,cost,local-first
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: openai==2.44.0; extra == "dev"
+Requires-Dist: httpx>=0.28; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Dynamic: license-file
+
+# RunPeek
+### by NemulAI
+
+See where your AI spends time and tokens.
+
+Watch supported AI workloads locally, understand estimated costs,
+and spot repeated failures and repeated work worth reviewing.
+
+RunPeek watches two things: the OpenAI Python SDK calls your own application
+makes (`runpeek run`), and the Claude Code sessions in a project
+(`runpeek watch`). It helps you answer *which customer or job caused these
+model calls*, *what did they consume*, *what would that cost at list prices*,
+and *where did the agent repeat itself*. Collection and analysis run entirely
+on your machine — no account, no service, no uploads, no runtime dependencies.
+
+**Sample output** (rendered from a test fixture, not a real session):
+
+```
+05:03  REPEATED READ
+       package.json was read 4 times in 2 minutes.
+       No edit to that file was observed between reads.
+       Repeated billing cannot be determined.
+
+       Evidence: runpeek session 719c4032
+
+05:04  REPEATED FAILURE
+       A python3 command failed 4 times consecutively over 46 seconds.
+       No edit or write was observed between the failures.
+       Check the error before repeating the command.
+
+       Evidence: runpeek session 719c4032
+
+05:04  TURN FINISHED
+       51 seconds · 8 tool calls (4 failed) · 8 model calls
+       API-equivalent estimate: $0.115
+       2 potential inefficiencies to review · runpeek session 719c4032
+```
+
+## Install
+
+RunPeek is not on PyPI yet. Install from a checkout (the repository below is
+the intended public location; until it is published, clone your local copy):
+
+```bash
+git clone https://github.com/AgentMulder404/runpeek.git && cd runpeek
+python -m venv .venv && . .venv/bin/activate
+pip install -e .            # runtime: no dependencies
+pip install -e ".[dev]"     # adds the openai SDK, httpx, pytest, ruff, mypy — needed for the offline demo and tests
+```
+
+Python 3.10+.
+
+## Quickstart A — watch Claude Code
+
+```bash
+runpeek watch --project /path/to/project
+```
+
+Keep using Claude Code normally in that project. The watcher first loads
+recent history (transcripts modified in the last 7 days; `--history all` or
+`--history none`) and summarises any historical findings without replaying
+them as live events. Then it prints only meaningful events: new sessions,
+turns starting and finishing, potential inefficiencies, and collection
+problems. Ctrl-C stops the watcher; your Claude session keeps running.
+
+Review afterwards:
+
+```bash
+runpeek sessions --project /path/to/project     # started, tool calls, errors, model calls, items to review
+runpeek findings --project /path/to/project     # potential inefficiencies, newest first
+runpeek session <session-id>                     # one session: activity, items with evidence, usage and estimate
+```
+
+`--project` defaults to the current directory; `--all-projects` covers every
+project Claude Code has transcripts for. If the filter finds nothing, RunPeek
+says so and names the projects it has collected.
+
+The Claude Code transcript adapter is **experimental**: it reads
+`~/.claude/projects/<project>/*.jsonl` (and `…/<session>/subagents/*.jsonl`),
+whose format is undocumented. It was built against transcripts written by
+Claude Code 2.1.x (CLI 2.1.258 verified) and marks other writer versions as
+`unknown_version`, parsed best-effort.
+
+## Quickstart B — observe a Python AI application
+
+```bash
+export OPENAI_API_KEY=…        # your application's own credentials; RunPeek never reads or stores them
+runpeek run python app.py
+```
+
+Optionally attribute calls from inside your code:
+
+```python
+import runpeek
+
+with runpeek.job(customer="acme", job="support_ticket"):
+    client.chat.completions.create(...)     # observed and attributed
+```
+
+Nested `job()` inherits `customer`; calls outside any `job()` are recorded as
+"No customer tag" — a real row with a real estimate, not a missing one.
+Context follows `await` and `asyncio.create_task`; for threads use
+`runpeek.wrap(fn)`, across processes `runpeek.inject()` / `runpeek.extract()`.
+
+When the application exits, RunPeek prints a summary. Later:
+
+```bash
+runpeek summary                     # latest run (add --verbose for the full accounting ledger)
+runpeek events --last 20            # per-call detail
+runpeek export --format jsonl --out run.jsonl
+runpeek reprice --pin openai-list@2026-09-09   # price under a separate pinned perspective
+```
+
+**Supported SDK surface:** `openai` Python SDK, `client.chat.completions.create`,
+synchronous, non-streaming — tested against `openai==2.44.0`. Streaming calls
+are recorded as observed-but-unmeasured (`stream=True`, no usage); `AsyncOpenAI`,
+the Responses API and other providers are not patched. `runpeek run` works for
+commands that start a CPython interpreter which processes `site` and inherits
+the environment (`python script.py` is tested; `-S`/`-I` and embedded
+interpreters are not covered). If you cannot use `runpeek run`, call
+`runpeek.install()` before importing the provider client.
+
+### Offline demo (no provider account)
+
+```bash
+runpeek run python examples/basic.py
+```
+
+`examples/basic.py` drives the real `openai` client through a local mock
+transport: three customers, an unknown model, a rate-limit error and a
+timeout. It needs the `[dev]` extras; the RunPeek runtime itself has no
+dependencies.
+
+**Sample output** (from that demo):
+
+```
+RUNPEEK / RUN COMPLETE
+
+python examples/basic.py
+Application exited successfully · telemetry saved
+
+8 model calls observed
+  6 completed · 2 failed
+
+$0.016052  known estimated API cost
+           5 of 8 calls priced — total is incomplete
+
+CUSTOMER           ESTIMATED COST    UNPRICED / UNKNOWN
+acme                     $0.01486                     0
+globex                   $0.00084                     1
+No customer tag         $0.000352                     0
+initech                         —                     2
+
+Missing from this estimate:
+• 1 call used a model with no known price (acme-preview-1)
+• 2 failed calls returned no usage
+
+Estimate at list prices — not verified provider billing.
+
+Stored locally · nothing uploaded
+Details: runpeek events · Full accounting: runpeek summary --verbose
+```
+
+## What RunPeek helps you find
+
+- Which customer or job the model calls belonged to, and what they consumed.
+- Calls that could not be priced (unknown model) or measured (errors,
+  streaming, missing usage) — shown beside the estimate, never folded into it.
+- In Claude Code sessions: the same command failing again and again with no
+  edit between attempts; the same file read repeatedly without an observed
+  edit; a tool erroring across many different inputs; one action looping
+  tightly. Each is a *potential* inefficiency — repetition is worth reviewing,
+  not proof of waste — with its evidence, a next step, and the limitation
+  needed to read it correctly.
+
+## How it works
+
+RunPeek is not a model, an agent framework, or a gateway. It does not run
+your prompts and needs no LLM or cloud account of its own. Its diagnostics
+are deterministic local analysis of what a supported source already records:
+the SDK's usage block, or the transcript Claude Code writes.
+
+```
+ Python app ──► openai SDK ──► provider        Claude Code ──► ~/.claude/projects/<proj>/*.jsonl
+      │  runpeek run: one patched method,                          │  runpeek watch: read-only polling,
+      │  exactly-once call, fail-open hooks                        │  checkpoints, no duplicates
+      ▼                                                            ▼
+ operations · attempts · observations           sessions · turns · tool calls · usage
+      └────────────► SQLite ./.runpeek/runpeek.db ◄────────────────┘
+                       accounting: charges → dated rate cards → estimates
+                       diagnostics: repeated failure · repeated read · retry loop
+          runpeek summary · events · export     runpeek sessions · session · findings
+```
+
+More in [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) and the full design in
+[`docs/DESIGN.md`](docs/DESIGN.md).
+
+## Supported integrations
+
+| Integration | Status | Notes |
+|---|---|---|
+| OpenAI Python SDK — `chat.completions.create`, sync, non-streaming | **Supported, tested** | `openai==2.44.0`; exactly-once, fail-open |
+| OpenAI — streaming | Observed, not measured | recorded as `unsupported_stream`, no usage, no cost |
+| OpenAI — `AsyncOpenAI`, Responses API | Not supported | not patched; invisible |
+| Claude Code transcripts (2.1.x) | **Supported, experimental** | undocumented format; version-gated adapter |
+| Claude Code source-reported cost | Not available | only in Claude Code's OpenTelemetry export, which RunPeek does not consume |
+| Codex | Not supported | capability check and adapter path in [`docs/AGENT_SOURCES.md`](docs/AGENT_SOURCES.md) |
+| Other providers, raw HTTP, other languages | Not supported | |
+| Dashboards, outcome tracking, run comparison, GPU accounting | Not built | see roadmap |
+
+## What the numbers mean
+
+- **Tokens** are reported by the source — the SDK's usage block, or the usage
+  Claude Code writes into its transcripts — not independently audited.
+- **Estimated cost** is a calculation from those tokens and a dated list-price
+  table ([`docs/PRICING.md`](docs/PRICING.md)). It is *not* your subscription
+  charge, quota usage, a reconciled bill, or a saving. For Claude Code it is
+  labelled "API-equivalent estimate" every time it appears.
+- **Unknown stays unknown.** A call with no usage, an unknown model, an error
+  or a timeout is counted and shown as unpriced or unknown, never as `$0`.
+- **Capture coverage** — how much AI activity RunPeek did not see — is not
+  measurable without an independent source. A run with no observations says
+  "this does not mean none happened".
+- **Findings are potential inefficiencies.** A repeated read shows a file was
+  requested again; whether its contents were billed again is not observable.
+  Only Edit/Write tool calls count as an observed change; command side effects
+  and edits outside the agent are invisible.
+- **Historical vs live.** The watcher summarises history at startup and marks
+  live events with their transcript timestamps; silence is never treated as a
+  stalled agent.
+- **Supported calls only.** RunPeek watches the surfaces listed above, not
+  every AI tool on your machine.
+
+## Privacy and local storage
+
+Everything lives in `./.runpeek/runpeek.db` (override: `--db`, `RUNPEEK_DB`),
+created `0600`. Stored: ids, timestamps, tool names, relative paths / program
+names / hostnames, token counts, model names, labels you set, and keyed
+fingerprints of tool arguments. Never stored: prompts, completions, tool
+inputs or outputs, commands, file contents, credentials. `runpeek export`
+writes the stored tables as JSONL with exact monetary values. Details and the
+fingerprint caveats: [`docs/PRIVACY.md`](docs/PRIVACY.md).
+
+## Known limitations
+
+- One SDK surface and one agent source; see the matrix above.
+- Claude Code transcript format is undocumented; a future Claude Code release
+  may change it. Affected sessions are marked, not silently misread.
+- Turn durations come from the transcript's own end-of-turn record; subagent
+  transcripts have none, so their turns show no duration.
+- The recorded command line for `runpeek run` is redacted heuristically
+  (inline programs, secret-looking values, URLs, payloads); it is not a
+  guarantee.
+- No benchmarks are published yet; performance targets in `docs/DESIGN.md`
+  are targets.
+- The real-provider smoke test (`examples/real_openai.py`) has not been run by
+  the maintainers; it needs your own key and costs a fraction of a cent. Nothing
+  in the test suite validates actual provider billing: mocked calls exercise the
+  accounting, and rate cards are dated transcriptions of list prices.
+
+## Development and tests
+
+```bash
+pip install -e ".[dev]"
+pytest                          # offline; real openai SDK over httpx.MockTransport
+ruff check src tests examples
+mypy                            # strict
+python -m build                 # sdist + wheel
+```
+
+The test suite covers exactly-once and fail-open hooks, fractional-cent
+pricing, cached/reasoning token handling, identity and correlation, idempotent
+estimates and repricing, bounded queue and shutdown, transcript ingestion
+(partial lines, truncation, rotation, restarts, concurrent sessions),
+diagnostics true/false positives, privacy of stored rows and exports, the
+terminal policy, legacy-name migration, and every command the UI prints.
+
+## Contributing
+
+See [`CONTRIBUTING.md`](CONTRIBUTING.md). Please keep tests offline and keep
+unknowns unknown. Security notes: [`SECURITY.md`](SECURITY.md).
+
+## Roadmap (short, not a promise)
+
+- Streaming usage (`stream_options.include_usage`) and async client support,
+  each behind its own tested gate.
+- Outcomes (`runpeek.outcome()`), cost per successful task, and run-to-run
+  comparison with a strict comparability check.
+- A Codex adapter once its session format or a documented interface is pinned.
+- Optional OpenTelemetry receiver for Claude Code's source-reported cost.
+
+## Migration from the NemulAI harness
+
+Names changed; data did not. `runpeek` replaces `nemulai` for the CLI and
+import; `RUNPEEK_*` replaces `NEMULAI_*` (legacy names still honoured); an
+existing `./.nemulai/nemulai.db` is used in place with a notice. Details:
+[`docs/MIGRATION.md`](docs/MIGRATION.md).
+
+## Running the real-provider check yourself
+
+`examples/real_openai.py` makes two tiny non-streaming calls and one streaming
+call against a real model (about $0.0001). Provide your key to the shell only,
+never to a chat or a file in the repository:
+
+```bash
+read -rs OPENAI_API_KEY && export OPENAI_API_KEY      # typed silently
+runpeek run python examples/real_openai.py
+unset OPENAI_API_KEY
+```
+
+Expect three attempts (two priced, one `unsupported_stream`), one
+"No customer tag" row, and `x-request-id` identifiers in `runpeek export`.
+
+## License
+
+Apache License 2.0 — see [`LICENSE`](LICENSE) and [`NOTICE`](NOTICE).