llm-cookie-bridge 0.1.0__tar.gz

llm_cookie_bridge-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,46 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build tooling
+        run: python -m pip install --upgrade build
+
+      - name: Build distributions
+        run: python -m build
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/*
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

llm_cookie_bridge-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.omx/
+.venv/
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/

llm_cookie_bridge-0.1.0/LICENSE

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

llm_cookie_bridge-0.1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: llm-cookie-bridge
+Version: 0.1.0
+Summary: Unified async cookie/session bridge for major AI web apps.
+Project-URL: Homepage, https://github.com/tkgo11/LLMCookieBridge
+Project-URL: Repository, https://github.com/tkgo11/LLMCookieBridge
+Project-URL: Issues, https://github.com/tkgo11/LLMCookieBridge/issues
+Author: tkgo11
+License: MIT
+License-File: LICENSE
+Keywords: async,chatgpt,claude,cookies,gemini,perplexity
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LLMCookieBridge
+
+`llm-cookie-bridge` is a unified async Python library for talking to major AI web apps using browser cookies or session-derived web tokens instead of official API keys.
+
+> Warning
+>
+> This package targets reverse-engineered web endpoints that may change without notice. Treat it as an unstable bridge, not a production SLA surface.
+
+## Implemented providers
+
+- Google Gemini web
+- ChatGPT / OpenAI web
+- Claude web
+- Perplexity web
+
+## Design notes
+
+- `httpx.AsyncClient` transport
+- per-provider auth bootstrap + best-effort refresh
+- unified async chat and streaming interface
+- minimal dependencies
+- unit-tested request builders and parsers with mocked transports
+- secure defaults: provider hosts are pinned and redirects are disabled unless explicitly opted in
+
+## Installation
+
+```bash
+pip install llm-cookie-bridge
+```
+
+## Quick start
+
+```python
+import asyncio
+import os
+from llm_cookie_bridge import LLMCookieBridge
+
+async def main() -> None:
+    bridge = LLMCookieBridge.create(
+        "chatgpt",
+        cookies={
+            "__Secure-next-auth.session-token": os.environ["CHATGPT_SESSION_TOKEN"],
+        },
+    )
+    async with bridge:
+        response = await bridge.chat("Say hello in one sentence.")
+        print(response.text)
+
+        async for chunk in bridge.stream("Stream a short poem."):
+            print(chunk.delta, end="", flush=True)
+
+asyncio.run(main())
+```
+
+## Provider examples
+
+### Gemini
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "gemini",
+    cookies={
+        "__Secure-1PSID": os.environ["GEMINI_1PSID"],
+        "__Secure-1PSIDTS": os.environ["GEMINI_1PSIDTS"],
+    },
+)
+```
+
+### ChatGPT / OpenAI web
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "chatgpt",
+    cookies={"__Secure-next-auth.session-token": os.environ["CHATGPT_SESSION_TOKEN"]},
+)
+```
+
+### Claude
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "claude",
+    cookie_header=os.environ["CLAUDE_COOKIE_HEADER"],
+)
+```
+
+### Perplexity
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "perplexity",
+    cookies={"__Secure-next-auth.session-token": os.environ["PERPLEXITY_SESSION_TOKEN"]},
+)
+```
+
+## Auto refresh
+
+Each provider exposes a best-effort `refresh()` implementation:
+
+- Gemini reboots app state and extracts `SNlM0e`, `bl`, and `f.sid`
+- ChatGPT re-fetches a bearer token from the web session endpoint when a next-auth cookie is present
+- Claude re-discovers the organization UUID and can use a custom refresh callback for cookie renewal
+- Perplexity re-primes the next-auth session endpoint and can use a custom refresh callback
+
+You can also inject a custom refresh callback:
+
+```python
+async def refresh_cookies(provider_name: str):
+    return {"sessionKey": "new-cookie-value"}
+
+bridge = LLMCookieBridge.create(
+    "claude",
+    cookie_header=os.environ["CLAUDE_COOKIE_HEADER"],
+    refresh_callback=refresh_cookies,
+)
+```
+
+## Security notes
+
+- Do not pass untrusted values into `cookies`, `cookie_header`, `headers`, or `base_url`.
+- `base_url` overrides are pinned to the provider host by default; cross-host overrides require `allow_custom_base_url=True`.
+- Custom `authorization`, `cookie`, `host`, `origin`, and `referer` headers are intentionally rejected.
+- Treat each bridge/provider instance as single-session and single-tenant; do not reuse one instance across multiple users.
+
+## API surface
+
+- `await bridge.chat(message, **kwargs)`
+- `async for chunk in bridge.stream(message, **kwargs)`
+- `await bridge.refresh(force=True)`
+
+## Research references
+
+These informed the request shapes and auth bootstraps, but are **not dependencies**:
+
+- Gemini: `HanaokaYuzu/Gemini-API`
+- ChatGPT: `acheong08/ChatGPT`, `lanqian528/chat2api`
+- Claude: `Xerxes-2/clewdr`, `st1vms/unofficial-claude-api`, `KoushikNavuluri/Claude-API`
+- Perplexity: `helallao/perplexity-ai`, `henrique-coder/perplexity-webui-scraper`, `nathanrchn/perplexityai`
+
+## Publishing
+
+This repository is configured for PyPI Trusted Publishing from GitHub Actions using `.github/workflows/publish.yml`.
+Create a GitHub Release after configuring the Trusted Publisher on PyPI to publish a new version automatically.

llm_cookie_bridge-0.1.0/README.md

@@ -0,0 +1,151 @@
+# LLMCookieBridge
+
+`llm-cookie-bridge` is a unified async Python library for talking to major AI web apps using browser cookies or session-derived web tokens instead of official API keys.
+
+> Warning
+>
+> This package targets reverse-engineered web endpoints that may change without notice. Treat it as an unstable bridge, not a production SLA surface.
+
+## Implemented providers
+
+- Google Gemini web
+- ChatGPT / OpenAI web
+- Claude web
+- Perplexity web
+
+## Design notes
+
+- `httpx.AsyncClient` transport
+- per-provider auth bootstrap + best-effort refresh
+- unified async chat and streaming interface
+- minimal dependencies
+- unit-tested request builders and parsers with mocked transports
+- secure defaults: provider hosts are pinned and redirects are disabled unless explicitly opted in
+
+## Installation
+
+```bash
+pip install llm-cookie-bridge
+```
+
+## Quick start
+
+```python
+import asyncio
+import os
+from llm_cookie_bridge import LLMCookieBridge
+
+async def main() -> None:
+    bridge = LLMCookieBridge.create(
+        "chatgpt",
+        cookies={
+            "__Secure-next-auth.session-token": os.environ["CHATGPT_SESSION_TOKEN"],
+        },
+    )
+    async with bridge:
+        response = await bridge.chat("Say hello in one sentence.")
+        print(response.text)
+
+        async for chunk in bridge.stream("Stream a short poem."):
+            print(chunk.delta, end="", flush=True)
+
+asyncio.run(main())
+```
+
+## Provider examples
+
+### Gemini
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "gemini",
+    cookies={
+        "__Secure-1PSID": os.environ["GEMINI_1PSID"],
+        "__Secure-1PSIDTS": os.environ["GEMINI_1PSIDTS"],
+    },
+)
+```
+
+### ChatGPT / OpenAI web
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "chatgpt",
+    cookies={"__Secure-next-auth.session-token": os.environ["CHATGPT_SESSION_TOKEN"]},
+)
+```
+
+### Claude
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "claude",
+    cookie_header=os.environ["CLAUDE_COOKIE_HEADER"],
+)
+```
+
+### Perplexity
+
+```python
+import os
+
+bridge = LLMCookieBridge.create(
+    "perplexity",
+    cookies={"__Secure-next-auth.session-token": os.environ["PERPLEXITY_SESSION_TOKEN"]},
+)
+```
+
+## Auto refresh
+
+Each provider exposes a best-effort `refresh()` implementation:
+
+- Gemini reboots app state and extracts `SNlM0e`, `bl`, and `f.sid`
+- ChatGPT re-fetches a bearer token from the web session endpoint when a next-auth cookie is present
+- Claude re-discovers the organization UUID and can use a custom refresh callback for cookie renewal
+- Perplexity re-primes the next-auth session endpoint and can use a custom refresh callback
+
+You can also inject a custom refresh callback:
+
+```python
+async def refresh_cookies(provider_name: str):
+    return {"sessionKey": "new-cookie-value"}
+
+bridge = LLMCookieBridge.create(
+    "claude",
+    cookie_header=os.environ["CLAUDE_COOKIE_HEADER"],
+    refresh_callback=refresh_cookies,
+)
+```
+
+## Security notes
+
+- Do not pass untrusted values into `cookies`, `cookie_header`, `headers`, or `base_url`.
+- `base_url` overrides are pinned to the provider host by default; cross-host overrides require `allow_custom_base_url=True`.
+- Custom `authorization`, `cookie`, `host`, `origin`, and `referer` headers are intentionally rejected.
+- Treat each bridge/provider instance as single-session and single-tenant; do not reuse one instance across multiple users.
+
+## API surface
+
+- `await bridge.chat(message, **kwargs)`
+- `async for chunk in bridge.stream(message, **kwargs)`
+- `await bridge.refresh(force=True)`
+
+## Research references
+
+These informed the request shapes and auth bootstraps, but are **not dependencies**:
+
+- Gemini: `HanaokaYuzu/Gemini-API`
+- ChatGPT: `acheong08/ChatGPT`, `lanqian528/chat2api`
+- Claude: `Xerxes-2/clewdr`, `st1vms/unofficial-claude-api`, `KoushikNavuluri/Claude-API`
+- Perplexity: `helallao/perplexity-ai`, `henrique-coder/perplexity-webui-scraper`, `nathanrchn/perplexityai`
+
+## Publishing
+
+This repository is configured for PyPI Trusted Publishing from GitHub Actions using `.github/workflows/publish.yml`.
+Create a GitHub Release after configuring the Trusted Publisher on PyPI to publish a new version automatically.

llm_cookie_bridge-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling>=1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "llm-cookie-bridge"
+version = "0.1.0"
+description = "Unified async cookie/session bridge for major AI web apps."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "tkgo11" }]
+keywords = ["async", "cookies", "chatgpt", "claude", "gemini", "perplexity"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: AsyncIO",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "httpx>=0.27,<1",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2",
+  "pytest>=8.0",
+  "pytest-asyncio>=0.23",
+  "twine>=5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/tkgo11/LLMCookieBridge"
+Repository = "https://github.com/tkgo11/LLMCookieBridge"
+Issues = "https://github.com/tkgo11/LLMCookieBridge/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/llm_cookie_bridge"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

llm_cookie_bridge-0.1.0/src/llm_cookie_bridge/__init__.py

@@ -0,0 +1,21 @@
+from .client import LLMCookieBridge
+from .exceptions import (
+    AuthenticationError,
+    BridgeError,
+    ParseError,
+    ProviderResponseError,
+    RateLimitError,
+)
+from .types import ChatChunk, ChatResponse, CookieRefreshResult
+
+__all__ = [
+    "AuthenticationError",
+    "BridgeError",
+    "ChatChunk",
+    "ChatResponse",
+    "CookieRefreshResult",
+    "LLMCookieBridge",
+    "ParseError",
+    "ProviderResponseError",
+    "RateLimitError",
+]

llm_cookie_bridge-0.1.0/src/llm_cookie_bridge/client.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Literal
+
+import httpx
+
+from .providers import ChatGPTProvider, ClaudeProvider, GeminiProvider, PerplexityProvider
+from .providers.base import BaseProvider
+from .types import ChatChunk, ChatResponse
+
+ProviderName = Literal["gemini", "chatgpt", "claude", "perplexity"]
+
+_PROVIDERS: dict[str, type[BaseProvider]] = {
+    "gemini": GeminiProvider,
+    "chatgpt": ChatGPTProvider,
+    "claude": ClaudeProvider,
+    "perplexity": PerplexityProvider,
+}
+
+
+class LLMCookieBridge:
+    def __init__(self, provider: BaseProvider) -> None:
+        self.provider = provider
+
+    @classmethod
+    def create(
+        cls,
+        provider: ProviderName,
+        *,
+        cookies: dict[str, str] | None = None,
+        cookie_header: str | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: float = 30.0,
+        transport: httpx.AsyncBaseTransport | None = None,
+        refresh_callback: Any = None,
+        allow_custom_base_url: bool = False,
+        follow_redirects: bool = False,
+        **provider_kwargs: Any,
+    ) -> "LLMCookieBridge":
+        provider_cls = _PROVIDERS[provider]
+        instance = provider_cls(
+            cookies=cookies,
+            cookie_header=cookie_header,
+            headers=headers,
+            timeout=timeout,
+            transport=transport,
+            refresh_callback=refresh_callback,
+            allow_custom_base_url=allow_custom_base_url,
+            follow_redirects=follow_redirects,
+            **provider_kwargs,
+        )
+        return cls(instance)
+
+    async def refresh(self, force: bool = False) -> None:
+        await self.provider.refresh(force=force)
+
+    async def chat(self, message: str, **kwargs: Any) -> ChatResponse:
+        return await self.provider.chat(message, **kwargs)
+
+    async def stream(self, message: str, **kwargs: Any) -> AsyncIterator[ChatChunk]:
+        async for chunk in self.provider.stream_chat(message, **kwargs):
+            yield chunk
+
+    async def aclose(self) -> None:
+        await self.provider.close()
+
+    async def __aenter__(self) -> "LLMCookieBridge":
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.aclose()

llm_cookie_bridge-0.1.0/src/llm_cookie_bridge/exceptions.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+class BridgeError(Exception):
+    """Base exception for llm-cookie-bridge."""
+
+
+class AuthenticationError(BridgeError):
+    """Raised when a provider cannot authenticate with the supplied cookies/session."""
+
+
+class ProviderResponseError(BridgeError):
+    """Raised when a provider returns a non-successful response."""
+
+    def __init__(self, provider: str, status_code: int, message: str) -> None:
+        super().__init__(f"{provider} returned HTTP {status_code}: {message}")
+        self.provider = provider
+        self.status_code = status_code
+        self.message = message
+
+
+class ParseError(BridgeError):
+    """Raised when a provider response cannot be parsed."""
+
+
+class RateLimitError(BridgeError):
+    """Raised when a provider indicates a rate or usage limit."""

llm_cookie_bridge-0.1.0/src/llm_cookie_bridge/providers/__init__.py

@@ -0,0 +1,13 @@
+from .base import BaseProvider
+from .chatgpt import ChatGPTProvider
+from .claude import ClaudeProvider
+from .gemini import GeminiProvider
+from .perplexity import PerplexityProvider
+
+__all__ = [
+    "BaseProvider",
+    "ChatGPTProvider",
+    "ClaudeProvider",
+    "GeminiProvider",
+    "PerplexityProvider",
+]