linklbee-scan 1.4.4__tar.gz

linklbee_scan-1.4.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NOTEGG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

linklbee_scan-1.4.4/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: linklbee-scan
+Version: 1.4.4
+Summary: Find where your LLM API bill leaks. One file, standard library only, zero network calls.
+Author-email: "NOTEGG Corp." <bee@linklbee.com>
+Maintainer-email: Chungnyung Kang <bee@linklbee.com>
+License-Expression: MIT
+Project-URL: Homepage, https://linklbee.com
+Project-URL: Repository, https://github.com/linklbee/scan
+Keywords: llm,openai,anthropic,cost-optimization,token,finops,prompt-caching,observability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+[한국어 → README.ko.md](https://github.com/linklbee/scan/blob/main/README.ko.md)
+
+# Linklbee scanner
+
+**Find where your LLM API bill leaks.** The scanner reads your LLM call log on your own machine and writes a one-page report of where token spend goes: prompts too short for the vendor's cache, the cache hit rate, prefixes repeated across calls, identical calls resent seconds apart, and failed or cut-off calls that were still billed. If your service writes new versions of the same documents, it also shows how much output could be saved by rewriting only the parts that changed.
+
+If the log lacks a field an item needs, the report does not guess. It names the field that would show the item. Every number comes from the log you give it.
+
+## Install and run
+
+```
+pip install linklbee-scan
+linklbee-scan <log file or folder> --lang en --out report.html
+linklbee-scan --demo --lang en          # see a report on a [synthetic] example log first
+```
+
+Python 3.9+, no dependencies. Reports are in Korean by default; `--lang en` gives English. Run it with no arguments and it looks in the current folder for something to read.
+
+Without pip, the whole tool is one file: download `linklbee_scan.py` and run `python3 linklbee_scan.py` with the same arguments.
+
+Not sure how your log will be read? `--peek` reads the first 200 records, prints which field comes from where, and writes nothing:
+
+```
+linklbee-scan calls.jsonl --peek --lang en
+```
+
+## Log formats it reads
+
+No conversion needed. JSONL, JSON arrays, CSV/TSV, `.log` and `.gz` files are read as they are; a folder is read file by file.
+
+| Format | |
+|---|---|
+| OpenAI · Anthropic | raw SDK responses (Chat Completions · Responses · Messages · Batch) |
+| CSV · TSV · JSON array | header row = field names / one element = one call |
+| Langfuse | observation export |
+| LangSmith | run export |
+| Helicone | request record |
+| LiteLLM | spend log |
+| Amazon Bedrock | model invocation log · Converse response |
+| Google Vertex AI · Gemini API | raw responses |
+| Azure OpenAI | Chat Completions log |
+
+Any other shape: map fields in one line, no script — `--map ts=created output=data.body.text output_tokens=meta.usage.out`.
+
+No call log, only the vendor's usage or cost file? Pass it as downloaded. It reads the OpenAI Usage and Costs APIs, OpenAI console usage and cost CSVs, the Anthropic usage report (Admin API), the Anthropic console cost CSV, the AWS Cost and Usage Report, Azure cost details, Fireworks usage and the Together cost CSV. You get spend by model, input vs output, cache reads and busy hours.
+
+A developer using Claude Code can try it on this machine's own records: `linklbee-scan --claude-code --lang en`.
+
+## What the report finds
+
+- Output's share of the bill — from `model` and token counts alone
+- How much of the output could be saved by editing the previous answer instead of writing it again
+- Calls that could be answered without a model call
+- Failed calls that were billed
+- Identical calls resent within seconds
+- Answers cut off at the length limit
+- Tool definitions and system text serialized inconsistently, which breaks the prompt cache
+- Prompts under the vendor's cache minimum
+- A billing check: billed output tokens against the answer text's own token count
+- Cache hit rate
+- Prefixes shared across calls that could be cached
+- Calls that could use OpenAI Flex
+
+Each item is reported as found, none, or needs more data — with the field that would show it.
+
+## No log file yet?
+
+Add these lines right after each call (OpenAI SDK; for Anthropic use `resp.content[0].text`, `u.input_tokens`, `u.output_tokens`). Once calls build up, run the scanner on `calls.jsonl`.
+
+```python
+import json, time
+def log_call(resp, path="calls.jsonl"):  # resp = what client.chat.completions.create(...) returned
+    u = resp.usage
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(json.dumps({"ts": time.time(), "output": resp.choices[0].message.content, "model": resp.model, "input_tokens": u.prompt_tokens, "output_tokens": u.completion_tokens}, ensure_ascii=False) + "\n")
+```
+
+TypeScript (Node, OpenAI SDK):
+
+```ts
+import { appendFileSync } from "node:fs";
+export function logCall(resp: any, path = "calls.jsonl") {  // resp = await client.chat.completions.create(...)
+  const u = resp.usage ?? {};
+  appendFileSync(path, JSON.stringify({ ts: Date.now() / 1000, output: resp.choices[0].message.content, model: resp.model, input_tokens: u.prompt_tokens, output_tokens: u.completion_tokens }) + "\n");
+}
+```
+
+## Privacy
+
+- **No network code.** No AI calls, no telemetry. Check it: `grep -cE "ht[t]p|sock[e]t|url[l]ib" linklbee_scan.py` prints `0`.
+- **Standard library only.** One file, nothing else to install or trust.
+- **Your log never leaves your machine.** Answer text is read in memory only; the report holds counts, shares and dollars — no prompts, no answers, no document keys.
+
+## License
+
+MIT (`LICENSE`), published by NOTEGG Corp. Copyright (c) 2026 NOTEGG. The embedded o200k token table is under tiktoken's MIT license (`THIRD_PARTY_NOTICES`).
+
+Full documentation — every field, `--flat`, `--hashify`, how to read the report, and its limits — is in [README.ko.md](https://github.com/linklbee/scan/blob/main/README.ko.md) (Korean, with the full English reference at the end under "English").

linklbee_scan-1.4.4/README.md

@@ -0,0 +1,98 @@
+[한국어 → README.ko.md](https://github.com/linklbee/scan/blob/main/README.ko.md)
+
+# Linklbee scanner
+
+**Find where your LLM API bill leaks.** The scanner reads your LLM call log on your own machine and writes a one-page report of where token spend goes: prompts too short for the vendor's cache, the cache hit rate, prefixes repeated across calls, identical calls resent seconds apart, and failed or cut-off calls that were still billed. If your service writes new versions of the same documents, it also shows how much output could be saved by rewriting only the parts that changed.
+
+If the log lacks a field an item needs, the report does not guess. It names the field that would show the item. Every number comes from the log you give it.
+
+## Install and run
+
+```
+pip install linklbee-scan
+linklbee-scan <log file or folder> --lang en --out report.html
+linklbee-scan --demo --lang en          # see a report on a [synthetic] example log first
+```
+
+Python 3.9+, no dependencies. Reports are in Korean by default; `--lang en` gives English. Run it with no arguments and it looks in the current folder for something to read.
+
+Without pip, the whole tool is one file: download `linklbee_scan.py` and run `python3 linklbee_scan.py` with the same arguments.
+
+Not sure how your log will be read? `--peek` reads the first 200 records, prints which field comes from where, and writes nothing:
+
+```
+linklbee-scan calls.jsonl --peek --lang en
+```
+
+## Log formats it reads
+
+No conversion needed. JSONL, JSON arrays, CSV/TSV, `.log` and `.gz` files are read as they are; a folder is read file by file.
+
+| Format | |
+|---|---|
+| OpenAI · Anthropic | raw SDK responses (Chat Completions · Responses · Messages · Batch) |
+| CSV · TSV · JSON array | header row = field names / one element = one call |
+| Langfuse | observation export |
+| LangSmith | run export |
+| Helicone | request record |
+| LiteLLM | spend log |
+| Amazon Bedrock | model invocation log · Converse response |
+| Google Vertex AI · Gemini API | raw responses |
+| Azure OpenAI | Chat Completions log |
+
+Any other shape: map fields in one line, no script — `--map ts=created output=data.body.text output_tokens=meta.usage.out`.
+
+No call log, only the vendor's usage or cost file? Pass it as downloaded. It reads the OpenAI Usage and Costs APIs, OpenAI console usage and cost CSVs, the Anthropic usage report (Admin API), the Anthropic console cost CSV, the AWS Cost and Usage Report, Azure cost details, Fireworks usage and the Together cost CSV. You get spend by model, input vs output, cache reads and busy hours.
+
+A developer using Claude Code can try it on this machine's own records: `linklbee-scan --claude-code --lang en`.
+
+## What the report finds
+
+- Output's share of the bill — from `model` and token counts alone
+- How much of the output could be saved by editing the previous answer instead of writing it again
+- Calls that could be answered without a model call
+- Failed calls that were billed
+- Identical calls resent within seconds
+- Answers cut off at the length limit
+- Tool definitions and system text serialized inconsistently, which breaks the prompt cache
+- Prompts under the vendor's cache minimum
+- A billing check: billed output tokens against the answer text's own token count
+- Cache hit rate
+- Prefixes shared across calls that could be cached
+- Calls that could use OpenAI Flex
+
+Each item is reported as found, none, or needs more data — with the field that would show it.
+
+## No log file yet?
+
+Add these lines right after each call (OpenAI SDK; for Anthropic use `resp.content[0].text`, `u.input_tokens`, `u.output_tokens`). Once calls build up, run the scanner on `calls.jsonl`.
+
+```python
+import json, time
+def log_call(resp, path="calls.jsonl"):  # resp = what client.chat.completions.create(...) returned
+    u = resp.usage
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(json.dumps({"ts": time.time(), "output": resp.choices[0].message.content, "model": resp.model, "input_tokens": u.prompt_tokens, "output_tokens": u.completion_tokens}, ensure_ascii=False) + "\n")
+```
+
+TypeScript (Node, OpenAI SDK):
+
+```ts
+import { appendFileSync } from "node:fs";
+export function logCall(resp: any, path = "calls.jsonl") {  // resp = await client.chat.completions.create(...)
+  const u = resp.usage ?? {};
+  appendFileSync(path, JSON.stringify({ ts: Date.now() / 1000, output: resp.choices[0].message.content, model: resp.model, input_tokens: u.prompt_tokens, output_tokens: u.completion_tokens }) + "\n");
+}
+```
+
+## Privacy
+
+- **No network code.** No AI calls, no telemetry. Check it: `grep -cE "ht[t]p|sock[e]t|url[l]ib" linklbee_scan.py` prints `0`.
+- **Standard library only.** One file, nothing else to install or trust.
+- **Your log never leaves your machine.** Answer text is read in memory only; the report holds counts, shares and dollars — no prompts, no answers, no document keys.
+
+## License
+
+MIT (`LICENSE`), published by NOTEGG Corp. Copyright (c) 2026 NOTEGG. The embedded o200k token table is under tiktoken's MIT license (`THIRD_PARTY_NOTICES`).
+
+Full documentation — every field, `--flat`, `--hashify`, how to read the report, and its limits — is in [README.ko.md](https://github.com/linklbee/scan/blob/main/README.ko.md) (Korean, with the full English reference at the end under "English").

linklbee_scan-1.4.4/linklbee_scan.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: linklbee-scan
+Version: 1.4.4
+Summary: Find where your LLM API bill leaks. One file, standard library only, zero network calls.
+Author-email: "NOTEGG Corp." <bee@linklbee.com>
+Maintainer-email: Chungnyung Kang <bee@linklbee.com>
+License-Expression: MIT
+Project-URL: Homepage, https://linklbee.com
+Project-URL: Repository, https://github.com/linklbee/scan
+Keywords: llm,openai,anthropic,cost-optimization,token,finops,prompt-caching,observability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+[한국어 → README.ko.md](https://github.com/linklbee/scan/blob/main/README.ko.md)
+
+# Linklbee scanner
+
+**Find where your LLM API bill leaks.** The scanner reads your LLM call log on your own machine and writes a one-page report of where token spend goes: prompts too short for the vendor's cache, the cache hit rate, prefixes repeated across calls, identical calls resent seconds apart, and failed or cut-off calls that were still billed. If your service writes new versions of the same documents, it also shows how much output could be saved by rewriting only the parts that changed.
+
+If the log lacks a field an item needs, the report does not guess. It names the field that would show the item. Every number comes from the log you give it.
+
+## Install and run
+
+```
+pip install linklbee-scan
+linklbee-scan <log file or folder> --lang en --out report.html
+linklbee-scan --demo --lang en          # see a report on a [synthetic] example log first
+```
+
+Python 3.9+, no dependencies. Reports are in Korean by default; `--lang en` gives English. Run it with no arguments and it looks in the current folder for something to read.
+
+Without pip, the whole tool is one file: download `linklbee_scan.py` and run `python3 linklbee_scan.py` with the same arguments.
+
+Not sure how your log will be read? `--peek` reads the first 200 records, prints which field comes from where, and writes nothing:
+
+```
+linklbee-scan calls.jsonl --peek --lang en
+```
+
+## Log formats it reads
+
+No conversion needed. JSONL, JSON arrays, CSV/TSV, `.log` and `.gz` files are read as they are; a folder is read file by file.
+
+| Format | |
+|---|---|
+| OpenAI · Anthropic | raw SDK responses (Chat Completions · Responses · Messages · Batch) |
+| CSV · TSV · JSON array | header row = field names / one element = one call |
+| Langfuse | observation export |
+| LangSmith | run export |
+| Helicone | request record |
+| LiteLLM | spend log |
+| Amazon Bedrock | model invocation log · Converse response |
+| Google Vertex AI · Gemini API | raw responses |
+| Azure OpenAI | Chat Completions log |
+
+Any other shape: map fields in one line, no script — `--map ts=created output=data.body.text output_tokens=meta.usage.out`.
+
+No call log, only the vendor's usage or cost file? Pass it as downloaded. It reads the OpenAI Usage and Costs APIs, OpenAI console usage and cost CSVs, the Anthropic usage report (Admin API), the Anthropic console cost CSV, the AWS Cost and Usage Report, Azure cost details, Fireworks usage and the Together cost CSV. You get spend by model, input vs output, cache reads and busy hours.
+
+A developer using Claude Code can try it on this machine's own records: `linklbee-scan --claude-code --lang en`.
+
+## What the report finds
+
+- Output's share of the bill — from `model` and token counts alone
+- How much of the output could be saved by editing the previous answer instead of writing it again
+- Calls that could be answered without a model call
+- Failed calls that were billed
+- Identical calls resent within seconds
+- Answers cut off at the length limit
+- Tool definitions and system text serialized inconsistently, which breaks the prompt cache
+- Prompts under the vendor's cache minimum
+- A billing check: billed output tokens against the answer text's own token count
+- Cache hit rate
+- Prefixes shared across calls that could be cached
+- Calls that could use OpenAI Flex
+
+Each item is reported as found, none, or needs more data — with the field that would show it.
+
+## No log file yet?
+
+Add these lines right after each call (OpenAI SDK; for Anthropic use `resp.content[0].text`, `u.input_tokens`, `u.output_tokens`). Once calls build up, run the scanner on `calls.jsonl`.
+
+```python
+import json, time
+def log_call(resp, path="calls.jsonl"):  # resp = what client.chat.completions.create(...) returned
+    u = resp.usage
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(json.dumps({"ts": time.time(), "output": resp.choices[0].message.content, "model": resp.model, "input_tokens": u.prompt_tokens, "output_tokens": u.completion_tokens}, ensure_ascii=False) + "\n")
+```
+
+TypeScript (Node, OpenAI SDK):
+
+```ts
+import { appendFileSync } from "node:fs";
+export function logCall(resp: any, path = "calls.jsonl") {  // resp = await client.chat.completions.create(...)
+  const u = resp.usage ?? {};
+  appendFileSync(path, JSON.stringify({ ts: Date.now() / 1000, output: resp.choices[0].message.content, model: resp.model, input_tokens: u.prompt_tokens, output_tokens: u.completion_tokens }) + "\n");
+}
+```
+
+## Privacy
+
+- **No network code.** No AI calls, no telemetry. Check it: `grep -cE "ht[t]p|sock[e]t|url[l]ib" linklbee_scan.py` prints `0`.
+- **Standard library only.** One file, nothing else to install or trust.
+- **Your log never leaves your machine.** Answer text is read in memory only; the report holds counts, shares and dollars — no prompts, no answers, no document keys.
+
+## License
+
+MIT (`LICENSE`), published by NOTEGG Corp. Copyright (c) 2026 NOTEGG. The embedded o200k token table is under tiktoken's MIT license (`THIRD_PARTY_NOTICES`).
+
+Full documentation — every field, `--flat`, `--hashify`, how to read the report, and its limits — is in [README.ko.md](https://github.com/linklbee/scan/blob/main/README.ko.md) (Korean, with the full English reference at the end under "English").

linklbee_scan-1.4.4/linklbee_scan.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+linklbee_scan.py
+pyproject.toml
+linklbee_scan.egg-info/PKG-INFO
+linklbee_scan.egg-info/SOURCES.txt
+linklbee_scan.egg-info/dependency_links.txt
+linklbee_scan.egg-info/entry_points.txt
+linklbee_scan.egg-info/top_level.txt

linklbee_scan-1.4.4/linklbee_scan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

linklbee_scan-1.4.4/linklbee_scan.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linklbee-scan = linklbee_scan:main

linklbee_scan-1.4.4/linklbee_scan.egg-info/top_level.txt

@@ -0,0 +1 @@
+linklbee_scan