kimi-nocost 0.1.1__tar.gz

kimi_nocost-0.1.1/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.env
+.venv/
+*.log
+attached_assets/

kimi_nocost-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 addy
+
+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.

kimi_nocost-0.1.1/PKG-INFO

@@ -0,0 +1,314 @@
+Metadata-Version: 2.4
+Name: kimi-nocost
+Version: 0.1.1
+Summary: Unofficial Python client for Kimi AI — no API key required, reverse-engineered
+Project-URL: Homepage, https://github.com/pooraddyy/kimi-nocost
+Project-URL: Repository, https://github.com/pooraddyy/kimi-nocost
+Project-URL: Issues, https://github.com/pooraddyy/kimi-nocost/issues
+Author-email: addy <pooraddyy@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai,chat,kimi,llm,moonshot,nocost,unofficial
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.32.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<h1>kimi-nocost</h1>
+
+<p>Unofficial Python client for <strong>Kimi AI</strong> (kimi.moonshot.cn). No API key needed — just your bearer token.</p>
+
+<a href="https://pypi.org/project/kimi-nocost/"><img src="https://img.shields.io/pypi/v/kimi-nocost?color=6c5ce7&label=PyPI&logo=pypi&logoColor=white&style=for-the-badge" alt="PyPI Version"/></a>
+<a href="https://pypi.org/project/kimi-nocost/"><img src="https://img.shields.io/pypi/pyversions/kimi-nocost?color=00b894&logo=python&logoColor=white&style=for-the-badge" alt="Python Versions"/></a>
+<a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-fdcb6e?style=for-the-badge&logo=opensourceinitiative&logoColor=white" alt="License"/></a>
+<a href="https://t.me/pythontodayz"><img src="https://img.shields.io/badge/Telegram-Join%20Channel-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram"/></a>
+
+</div>
+
+---
+
+## Features
+
+- No API key required — uses your browser session token
+- Persistent sessions — messages stay in the same conversation automatically
+- Streaming support — yield reply chunks in real time
+- Web search — toggle Kimi's built-in search on any message
+- Multi-turn conversations — full context preserved across calls
+- Image upload — send up to 20 images at once
+- File upload — send documents, PDFs, code files (max 100 MB each, 1,000 files, 10 GB total)
+- Built-in Models — switch models easily with `Models.K2D6`, `Models.K2D6_THINKING`, etc.
+- Lightweight — only depends on `requests`
+
+---
+
+## Install
+
+```bash
+pip install kimi-nocost
+```
+
+---
+
+## Quick Start
+
+```python
+from kimi_nocost import KimiClient
+
+client = KimiClient(token="your-kimi-bearer-token", model="kimi")
+
+reply = client.chat("What is the capital of France?")
+print(reply)
+```
+
+> `model` is required. Pass it as a plain string — `"kimi"`, `"k2d6"`, `"k2d6-thinking"`, etc.
+> Omitting it raises a `TypeError`.
+
+---
+
+## Models
+
+Use the built-in `Models` class to switch between Kimi models:
+
+```python
+from kimi_nocost import KimiClient, Models
+
+client = KimiClient(token="your-token", model="k2d6")  # plain string
+
+reply = client.chat("Explain transformers")
+print(reply)
+
+client.model = Models.K2D6_THINKING
+reply = client.chat("Solve this step by step: 2x + 5 = 13")
+print(reply)
+```
+
+| Constant | Model ID | Description |
+|----------|----------|-------------|
+| `Models.KIMI` | `kimi` | Default model |
+| `Models.K1` | `k1` | K1 model |
+| `Models.K2D6` | `k2d6` | K2.6 Instant — fast responses |
+| `Models.K2D6_THINKING` | `k2d6-thinking` | K2.6 Thinking — deep reasoning |
+| `Models.K2D6_AGENT` | `k2d6-agent` | K2.6 Agent — research, slides, docs |
+| `Models.K2D6_AGENT_ULTRA` | `k2d6-agent-ultra` | K2.6 Agent Ultra |
+| `Models.OK_COMPUTER` | `ok-computer` | OK Computer agent |
+
+---
+
+## Multi-Turn Conversation
+
+```python
+client = KimiClient(token="your-token")
+
+reply1 = client.chat("My name is Alex.")
+reply2 = client.chat("What is my name?")
+print(reply2)
+```
+
+---
+
+## Streaming
+
+```python
+from kimi_nocost import KimiClient
+
+client = KimiClient(token="your-token")
+
+for chunk in client.stream("Explain quantum computing in simple terms"):
+    print(chunk, end="", flush=True)
+```
+
+---
+
+## With Web Search
+
+```python
+reply = client.chat("Latest news on AI today", use_search=True)
+```
+
+---
+
+## Image Upload
+
+Send up to 20 images in a single call:
+
+```python
+from kimi_nocost import KimiClient
+
+client = KimiClient(token="your-token")
+
+file_ids = client.upload_images([
+    "photo1.jpg",
+    "photo2.png",
+    (open("screenshot.png", "rb"), "screenshot.png"),
+])
+
+reply = client.chat("Describe these images", refs=file_ids)
+print(reply)
+```
+
+---
+
+## File Upload
+
+Send documents, PDFs, or code files (max 100 MB each, 1,000 files per session, 10 GB total):
+
+```python
+file_id = client.upload_file("report.pdf")
+
+reply = client.chat("Summarize this document", refs=[file_id])
+print(reply)
+```
+
+You can also pass raw bytes with a filename:
+
+```python
+import io
+
+content = b"def hello(): print('world')"
+file_id = client.upload_file(io.BytesIO(content), "hello.py")
+
+reply = client.chat("What does this code do?", refs=[file_id])
+print(reply)
+```
+
+---
+
+## Starting a New Chat
+
+```python
+client.new_chat(name="fresh-start")
+reply = client.chat("Let's start over.")
+```
+
+---
+
+## Manual Chat ID
+
+```python
+chat_id = client.new_chat(name="my-session")
+
+reply1 = client.chat("My name is Alex.", chat_id=chat_id)
+reply2 = client.chat("What is my name?", chat_id=chat_id)
+print(reply2)
+```
+
+---
+
+## API Reference
+
+### `KimiClient(token, model=Models.KIMI, timeout=60)`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `token` | `str` | Bearer JWT from kimi.moonshot.cn |
+| `model` | `str` | Model ID — use `Models.*` constants |
+| `timeout` | `int` | HTTP timeout in seconds |
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `chat(message, chat_id, history, use_search, refs)` | `str` | Send a message, get full reply |
+| `stream(message, chat_id, history, use_search, refs)` | `Generator[str]` | Send a message, yield reply chunks |
+| `new_chat(name)` | `str` | Create a new conversation and set it as active |
+| `upload_file(file, filename)` | `str` | Upload a file, returns file ID |
+| `upload_images(files)` | `List[str]` | Upload up to 20 images, returns list of file IDs |
+| `upload_single(file, filename)` | `str` | Upload a single file or image, returns file ID |
+
+### Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `model` | `str` | Current model — change anytime |
+| `chat_id` | `str` | Active conversation ID |
+| `file_count` | `int` | Number of files uploaded this session |
+| `total_size` | `int` | Total bytes uploaded this session |
+
+---
+
+## REST API Server
+
+The included Flask server exposes HTTP endpoints:
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `POST /chat/new` | POST | Create a new session → returns `chat_id` |
+| `POST /chat` | POST | Send a message → returns `reply` + `chat_id` |
+| `POST /chat/stream` | POST | Stream a reply as plain text |
+| `POST /upload/images` | POST | Upload up to 20 images → returns `file_ids` |
+| `POST /upload/file` | POST | Upload a single file → returns `file_id` |
+| `GET /health` | GET | Health check |
+
+Pass your token via `Authorization: Bearer <token>` header.
+
+**Chat with files:**
+```json
+{
+  "message": "Summarize this",
+  "file_ids": ["id1", "id2"],
+  "model": "k2d6-thinking"
+}
+```
+
+**Upload images** (multipart, field name `images`):
+```bash
+curl -H "Authorization: Bearer <token>" \
+  -F "images=@photo1.jpg" \
+  -F "images=@photo2.png" \
+  http://localhost:8080/upload/images
+```
+
+**Upload file** (multipart, field name `file`):
+```bash
+curl -H "Authorization: Bearer <token>" \
+  -F "file=@report.pdf" \
+  http://localhost:8080/upload/file
+```
+
+---
+
+## Getting Your Token
+
+1. Open [kimi.moonshot.cn](https://kimi.moonshot.cn) in your browser
+2. Open **DevTools** → **Network** → any request
+3. Copy the value of `Authorization: Bearer <token>`
+
+Or from iOS/Android using a MITM proxy (e.g. mitmproxy, Charles).
+
+The token is a JWT that lasts ~30 days.
+
+---
+
+## Demo
+
+See [DEMO.md](DEMO.md) for a full working Telegram bot with image & file upload support.
+
+---
+
+## Community
+
+<div align="center">
+
+<a href="https://t.me/pythontodayz">
+  <img src="https://img.shields.io/badge/Telegram-%40pythontodayz-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Channel"/>
+</a>
+
+Join for Python tutorials, projects, and updates → [t.me/pythontodayz](https://t.me/pythontodayz)
+
+</div>
+
+---
+
+## License
+
+MIT — made by [addy](https://t.me/pythontodayz)

kimi_nocost-0.1.1/README.md

@@ -0,0 +1,290 @@
+<div align="center">
+
+<h1>kimi-nocost</h1>
+
+<p>Unofficial Python client for <strong>Kimi AI</strong> (kimi.moonshot.cn). No API key needed — just your bearer token.</p>
+
+<a href="https://pypi.org/project/kimi-nocost/"><img src="https://img.shields.io/pypi/v/kimi-nocost?color=6c5ce7&label=PyPI&logo=pypi&logoColor=white&style=for-the-badge" alt="PyPI Version"/></a>
+<a href="https://pypi.org/project/kimi-nocost/"><img src="https://img.shields.io/pypi/pyversions/kimi-nocost?color=00b894&logo=python&logoColor=white&style=for-the-badge" alt="Python Versions"/></a>
+<a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-fdcb6e?style=for-the-badge&logo=opensourceinitiative&logoColor=white" alt="License"/></a>
+<a href="https://t.me/pythontodayz"><img src="https://img.shields.io/badge/Telegram-Join%20Channel-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram"/></a>
+
+</div>
+
+---
+
+## Features
+
+- No API key required — uses your browser session token
+- Persistent sessions — messages stay in the same conversation automatically
+- Streaming support — yield reply chunks in real time
+- Web search — toggle Kimi's built-in search on any message
+- Multi-turn conversations — full context preserved across calls
+- Image upload — send up to 20 images at once
+- File upload — send documents, PDFs, code files (max 100 MB each, 1,000 files, 10 GB total)
+- Built-in Models — switch models easily with `Models.K2D6`, `Models.K2D6_THINKING`, etc.
+- Lightweight — only depends on `requests`
+
+---
+
+## Install
+
+```bash
+pip install kimi-nocost
+```
+
+---
+
+## Quick Start
+
+```python
+from kimi_nocost import KimiClient
+
+client = KimiClient(token="your-kimi-bearer-token", model="kimi")
+
+reply = client.chat("What is the capital of France?")
+print(reply)
+```
+
+> `model` is required. Pass it as a plain string — `"kimi"`, `"k2d6"`, `"k2d6-thinking"`, etc.
+> Omitting it raises a `TypeError`.
+
+---
+
+## Models
+
+Use the built-in `Models` class to switch between Kimi models:
+
+```python
+from kimi_nocost import KimiClient, Models
+
+client = KimiClient(token="your-token", model="k2d6")  # plain string
+
+reply = client.chat("Explain transformers")
+print(reply)
+
+client.model = Models.K2D6_THINKING
+reply = client.chat("Solve this step by step: 2x + 5 = 13")
+print(reply)
+```
+
+| Constant | Model ID | Description |
+|----------|----------|-------------|
+| `Models.KIMI` | `kimi` | Default model |
+| `Models.K1` | `k1` | K1 model |
+| `Models.K2D6` | `k2d6` | K2.6 Instant — fast responses |
+| `Models.K2D6_THINKING` | `k2d6-thinking` | K2.6 Thinking — deep reasoning |
+| `Models.K2D6_AGENT` | `k2d6-agent` | K2.6 Agent — research, slides, docs |
+| `Models.K2D6_AGENT_ULTRA` | `k2d6-agent-ultra` | K2.6 Agent Ultra |
+| `Models.OK_COMPUTER` | `ok-computer` | OK Computer agent |
+
+---
+
+## Multi-Turn Conversation
+
+```python
+client = KimiClient(token="your-token")
+
+reply1 = client.chat("My name is Alex.")
+reply2 = client.chat("What is my name?")
+print(reply2)
+```
+
+---
+
+## Streaming
+
+```python
+from kimi_nocost import KimiClient
+
+client = KimiClient(token="your-token")
+
+for chunk in client.stream("Explain quantum computing in simple terms"):
+    print(chunk, end="", flush=True)
+```
+
+---
+
+## With Web Search
+
+```python
+reply = client.chat("Latest news on AI today", use_search=True)
+```
+
+---
+
+## Image Upload
+
+Send up to 20 images in a single call:
+
+```python
+from kimi_nocost import KimiClient
+
+client = KimiClient(token="your-token")
+
+file_ids = client.upload_images([
+    "photo1.jpg",
+    "photo2.png",
+    (open("screenshot.png", "rb"), "screenshot.png"),
+])
+
+reply = client.chat("Describe these images", refs=file_ids)
+print(reply)
+```
+
+---
+
+## File Upload
+
+Send documents, PDFs, or code files (max 100 MB each, 1,000 files per session, 10 GB total):
+
+```python
+file_id = client.upload_file("report.pdf")
+
+reply = client.chat("Summarize this document", refs=[file_id])
+print(reply)
+```
+
+You can also pass raw bytes with a filename:
+
+```python
+import io
+
+content = b"def hello(): print('world')"
+file_id = client.upload_file(io.BytesIO(content), "hello.py")
+
+reply = client.chat("What does this code do?", refs=[file_id])
+print(reply)
+```
+
+---
+
+## Starting a New Chat
+
+```python
+client.new_chat(name="fresh-start")
+reply = client.chat("Let's start over.")
+```
+
+---
+
+## Manual Chat ID
+
+```python
+chat_id = client.new_chat(name="my-session")
+
+reply1 = client.chat("My name is Alex.", chat_id=chat_id)
+reply2 = client.chat("What is my name?", chat_id=chat_id)
+print(reply2)
+```
+
+---
+
+## API Reference
+
+### `KimiClient(token, model=Models.KIMI, timeout=60)`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `token` | `str` | Bearer JWT from kimi.moonshot.cn |
+| `model` | `str` | Model ID — use `Models.*` constants |
+| `timeout` | `int` | HTTP timeout in seconds |
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `chat(message, chat_id, history, use_search, refs)` | `str` | Send a message, get full reply |
+| `stream(message, chat_id, history, use_search, refs)` | `Generator[str]` | Send a message, yield reply chunks |
+| `new_chat(name)` | `str` | Create a new conversation and set it as active |
+| `upload_file(file, filename)` | `str` | Upload a file, returns file ID |
+| `upload_images(files)` | `List[str]` | Upload up to 20 images, returns list of file IDs |
+| `upload_single(file, filename)` | `str` | Upload a single file or image, returns file ID |
+
+### Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `model` | `str` | Current model — change anytime |
+| `chat_id` | `str` | Active conversation ID |
+| `file_count` | `int` | Number of files uploaded this session |
+| `total_size` | `int` | Total bytes uploaded this session |
+
+---
+
+## REST API Server
+
+The included Flask server exposes HTTP endpoints:
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `POST /chat/new` | POST | Create a new session → returns `chat_id` |
+| `POST /chat` | POST | Send a message → returns `reply` + `chat_id` |
+| `POST /chat/stream` | POST | Stream a reply as plain text |
+| `POST /upload/images` | POST | Upload up to 20 images → returns `file_ids` |
+| `POST /upload/file` | POST | Upload a single file → returns `file_id` |
+| `GET /health` | GET | Health check |
+
+Pass your token via `Authorization: Bearer <token>` header.
+
+**Chat with files:**
+```json
+{
+  "message": "Summarize this",
+  "file_ids": ["id1", "id2"],
+  "model": "k2d6-thinking"
+}
+```
+
+**Upload images** (multipart, field name `images`):
+```bash
+curl -H "Authorization: Bearer <token>" \
+  -F "images=@photo1.jpg" \
+  -F "images=@photo2.png" \
+  http://localhost:8080/upload/images
+```
+
+**Upload file** (multipart, field name `file`):
+```bash
+curl -H "Authorization: Bearer <token>" \
+  -F "file=@report.pdf" \
+  http://localhost:8080/upload/file
+```
+
+---
+
+## Getting Your Token
+
+1. Open [kimi.moonshot.cn](https://kimi.moonshot.cn) in your browser
+2. Open **DevTools** → **Network** → any request
+3. Copy the value of `Authorization: Bearer <token>`
+
+Or from iOS/Android using a MITM proxy (e.g. mitmproxy, Charles).
+
+The token is a JWT that lasts ~30 days.
+
+---
+
+## Demo
+
+See [DEMO.md](DEMO.md) for a full working Telegram bot with image & file upload support.
+
+---
+
+## Community
+
+<div align="center">
+
+<a href="https://t.me/pythontodayz">
+  <img src="https://img.shields.io/badge/Telegram-%40pythontodayz-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Channel"/>
+</a>
+
+Join for Python tutorials, projects, and updates → [t.me/pythontodayz](https://t.me/pythontodayz)
+
+</div>
+
+---
+
+## License
+
+MIT — made by [addy](https://t.me/pythontodayz)

kimi_nocost-0.1.1/kimi_nocost/__init__.py

@@ -0,0 +1,6 @@
+from .client import KimiClient
+from .errors import KimiAPIError, KimiAuthError, KimiError, KimiSessionLimitError, KimiUploadError
+from .models import Models
+
+__all__ = ["KimiClient", "KimiError", "KimiAuthError", "KimiAPIError", "KimiUploadError", "KimiSessionLimitError", "Models"]
+__version__ = "0.1.1"

kimi_nocost-0.1.1/kimi_nocost/client.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import io
+import json
+import os
+from typing import Generator, List, Union
+
+import requests
+
+from .errors import KimiAPIError, KimiAuthError, KimiSessionLimitError, KimiUploadError
+from .models import Models
+from .session import build_headers, create_chat, new_id, stream_completion, upload_file
+
+MAX_FILE_SIZE = 100 * 1024 * 1024
+MAX_FILES = 1000
+MAX_TOTAL_SIZE = 10 * 1024 * 1024 * 1024
+MAX_IMAGES_PER_CALL = 20
+
+FileInput = Union[str, os.PathLike, bytes, io.IOBase]
+
+
+class KimiClient:
+    def __init__(
+        self,
+        token: str,
+        model: str,
+        timeout: int = 60,
+    ) -> None:
+        if not token:
+            raise KimiAuthError("token is required")
+        if not model:
+            raise KimiAuthError("model is required — e.g. model='kimi' or model='k2d6'")
+        self.token = token
+        self.model = model
+        self.timeout = timeout
+        self.device_id = new_id()
+        self.session_id = new_id()
+        self.chat_id: str = ""
+        self.file_count: int = 0
+        self.total_size: int = 0
+        self.http = requests.Session()
+        self.http.headers.update(build_headers(token, self.device_id, self.session_id))
+
+    def new_chat(self, name: str = "") -> str:
+        self.chat_id = create_chat(self.http, name, self.timeout)
+        return self.chat_id
+
+    def upload_single(self, file: FileInput, filename: str | None = None) -> str:
+        if isinstance(file, (str, os.PathLike)):
+            path = str(file)
+            filename = filename or os.path.basename(path)
+            size = os.path.getsize(path)
+            if size > MAX_FILE_SIZE:
+                raise KimiUploadError(f"{filename} exceeds 100 MB limit")
+            if self.file_count >= MAX_FILES:
+                raise KimiUploadError("max 1,000 files per user exceeded")
+            if self.total_size + size > MAX_TOTAL_SIZE:
+                raise KimiUploadError("total upload limit of 10 GB exceeded")
+            with open(path, "rb") as fh:
+                file_id = upload_file(self.http, fh, filename, self.timeout)
+            self.file_count += 1
+            self.total_size += size
+            return file_id
+
+        if isinstance(file, bytes):
+            data = file
+            file_obj = io.BytesIO(data)
+        elif isinstance(file, io.IOBase):
+            data = file.read()
+            file_obj = io.BytesIO(data)
+        else:
+            raise KimiUploadError("file must be a path, bytes, or file-like object")
+
+        if not filename:
+            raise KimiUploadError("filename is required for bytes/stream uploads")
+        size = len(data)
+        if size > MAX_FILE_SIZE:
+            raise KimiUploadError(f"{filename} exceeds 100 MB limit")
+        if self.file_count >= MAX_FILES:
+            raise KimiUploadError("max 1,000 files per user exceeded")
+        if self.total_size + size > MAX_TOTAL_SIZE:
+            raise KimiUploadError("total upload limit of 10 GB exceeded")
+        file_id = upload_file(self.http, file_obj, filename, self.timeout)
+        self.file_count += 1
+        self.total_size += size
+        return file_id
+
+    def upload_images(
+        self,
+        files: List[Union[FileInput, tuple]],
+    ) -> List[str]:
+        if len(files) > MAX_IMAGES_PER_CALL:
+            raise KimiUploadError(f"max {MAX_IMAGES_PER_CALL} images per call")
+        ids = []
+        for item in files:
+            if isinstance(item, tuple):
+                file_id = self.upload_single(item[0], item[1] if len(item) > 1 else None)
+            else:
+                file_id = self.upload_single(item)
+            ids.append(file_id)
+        return ids
+
+    def upload_file(
+        self,
+        file: FileInput,
+        filename: str | None = None,
+    ) -> str:
+        return self.upload_single(file, filename)
+
+    def chat(
+        self,
+        message: str,
+        chat_id: str = "",
+        history: list | None = None,
+        use_search: bool = False,
+        refs: list | None = None,
+    ) -> str:
+        return "".join(
+            self.stream(
+                message,
+                chat_id=chat_id,
+                history=history,
+                use_search=use_search,
+                refs=refs,
+            )
+        )
+
+    def stream(
+        self,
+        message: str,
+        chat_id: str = "",
+        history: list | None = None,
+        use_search: bool = False,
+        refs: list | None = None,
+    ) -> Generator[str, None, None]:
+        active_chat_id = chat_id or self.chat_id
+        if not active_chat_id:
+            active_chat_id = self.new_chat()
+        else:
+            self.chat_id = active_chat_id
+
+        messages = list(history or []) + [{"role": "user", "content": message}]
+
+        resp = stream_completion(
+            self.http,
+            active_chat_id,
+            messages,
+            self.model,
+            use_search,
+            self.timeout,
+            refs_file=refs or [],
+        )
+
+        if not resp.ok:
+            raise KimiAPIError(str(resp.status_code), resp.text[:300])
+
+        for raw in resp.iter_lines():
+            if not raw:
+                continue
+            line = raw.decode("utf-8") if isinstance(raw, bytes) else raw
+            if not line.startswith("data:"):
+                continue
+            data = line[5:].strip()
+            if data == "[DONE]":
+                break
+            try:
+                obj = json.loads(data)
+            except (json.JSONDecodeError, ValueError):
+                continue
+            event = obj.get("event", "")
+            if event == "cmpl" and "text" in obj:
+                yield obj["text"]
+            elif event == "all_done":
+                break
+            elif "error_type" in obj or "error" in obj:
+                code = obj.get("error_type") or str(obj.get("error", "unknown"))
+                detail = obj.get("message", "")
+                limit_keywords = (
+                    "context_length", "token_limit", "too_long",
+                    "context_limit", "length_exceed", "conversation_too_long",
+                    "chat_context", "max_tokens",
+                )
+                if any(kw in code.lower() or kw in detail.lower() for kw in limit_keywords):
+                    raise KimiSessionLimitError(code)
+                raise KimiAPIError(code, detail)

kimi_nocost-0.1.1/kimi_nocost/errors.py

@@ -0,0 +1,24 @@
+class KimiError(Exception):
+    pass
+
+
+class KimiAuthError(KimiError):
+    pass
+
+
+class KimiAPIError(KimiError):
+    def __init__(self, code, detail=""):
+        self.code = code
+        self.detail = detail
+        msg = f"Kimi API error: {code}"
+        if detail:
+            msg += f" — {detail}"
+        super().__init__(msg)
+
+
+class KimiUploadError(KimiError):
+    pass
+
+
+class KimiSessionLimitError(KimiError):
+    pass

kimi_nocost-0.1.1/kimi_nocost/models.py

@@ -0,0 +1,8 @@
+class Models:
+    KIMI = "kimi"
+    K1 = "k1"
+    K2D6 = "k2d6"
+    K2D6_THINKING = "k2d6-thinking"
+    K2D6_AGENT = "k2d6-agent"
+    K2D6_AGENT_ULTRA = "k2d6-agent-ultra"
+    OK_COMPUTER = "ok-computer"

kimi_nocost-0.1.1/kimi_nocost/session.py

@@ -0,0 +1,72 @@
+import mimetypes
+import uuid
+import requests
+
+BASE = "https://kimi.moonshot.cn"
+FILE_BASE = "https://www.kimi.com/apiv2-files"
+
+
+def new_id():
+    return uuid.uuid4().hex
+
+
+def build_headers(token, device_id, session_id):
+    return {
+        "User-Agent": (
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/135.0.0.0 Safari/537.36"
+        ),
+        "Authorization": f"Bearer {token}",
+        "Referer": "https://kimi.moonshot.cn/",
+        "Origin": "https://kimi.moonshot.cn",
+        "x-msh-device-id": device_id,
+        "x-msh-session-id": session_id,
+        "x-language": "en-US",
+    }
+
+
+def create_chat(http, name, timeout):
+    name = name or f"chat-{uuid.uuid4().hex[:8]}"
+    r = http.post(
+        f"{BASE}/api/chat",
+        json={"name": name, "is_example": False},
+        timeout=timeout,
+    )
+    r.raise_for_status()
+    return r.json()["id"]
+
+
+def upload_file(http, file_obj, filename, timeout):
+    content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    extra_headers = {
+        "Upload-Draft-Interop-Version": "6",
+        "Upload-Complete": "?1",
+    }
+    r = http.post(
+        f"{FILE_BASE}/file/upload",
+        files={"file": (filename, file_obj, content_type)},
+        headers=extra_headers,
+        timeout=timeout,
+    )
+    r.raise_for_status()
+    return r.json()["file"]["id"]
+
+
+def stream_completion(http, chat_id, messages, model, use_search, timeout, refs_file=None):
+    body = {
+        "messages": messages,
+        "use_search": use_search,
+        "extend": {"sidebar": True},
+        "kimiplus_id": model,
+        "use_research": False,
+        "refs": [],
+        "refs_file": refs_file or [],
+    }
+    return http.post(
+        f"{BASE}/api/chat/{chat_id}/completion/stream",
+        json=body,
+        stream=True,
+        headers={"Content-Type": "application/json", "Accept": "text/event-stream"},
+        timeout=timeout,
+    )

kimi_nocost-0.1.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "kimi-nocost"
+version = "0.1.1"
+description = "Unofficial Python client for Kimi AI — no API key required, reverse-engineered"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "addy", email = "pooraddyy@gmail.com" }]
+keywords = ["kimi", "moonshot", "ai", "chat", "llm", "unofficial", "nocost"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = ["requests>=2.32.0"]
+
+[project.urls]
+Homepage = "https://github.com/pooraddyy/kimi-nocost"
+Repository = "https://github.com/pooraddyy/kimi-nocost"
+Issues = "https://github.com/pooraddyy/kimi-nocost/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["kimi_nocost"]
+
+[tool.hatch.build.targets.sdist]
+include = ["kimi_nocost/", "README.md", "pyproject.toml", "LICENSE"]