open-langchain 0.6.1__tar.gz

open_langchain-0.6.1/.gitignore

@@ -0,0 +1,9 @@
+node_modules
+dist
+build
+*.egg-info
+__pycache__
+.pytest_cache
+.venv
+*.log
+.DS_Store

open_langchain-0.6.1/LICENSE

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

open_langchain-0.6.1/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: open-langchain
+Version: 0.6.1
+Summary: Native LangChain chat models for OpenAI Codex subscription OAuth and OpenCode Zen/Go — no Node sidecar.
+Project-URL: Homepage, https://github.com/cgaravitoq/open-langchain
+Project-URL: Repository, https://github.com/cgaravitoq/open-langchain
+Author: cgaravitoq
+License: MIT
+License-File: LICENSE
+Keywords: chat-model,codex,langchain,langgraph,llm,openai,opencode
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-core<2,>=0.3.15
+Requires-Dist: langchain-openai>=0.2
+Provides-Extra: test
+Requires-Dist: langchain-tests>=0.3.5; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest-socket>=0.7; extra == 'test'
+Requires-Dist: pytest>=7.4; extra == 'test'
+Description-Content-Type: text/markdown
+
+# open-langchain
+
+Native LangChain chat models for **OpenAI Codex** (ChatGPT Plus/Pro
+subscription OAuth), **Claude** (Claude Code subscription OAuth), and
+**OpenCode Zen/Go**. No Pi runtime, no Node sidecar.
+
+## Requirements
+
+- Python >= 3.9
+- For Codex: an `openai-codex` credential in `~/.pi/agent/auth.json`, or sign in
+  with `codex-login`
+- For Claude Code: the Claude Code CLI logged in once (`~/.claude/.credentials.json`)
+- For paid OpenCode models: `OPENCODE_API_KEY` or an explicit `api_key`
+
+## Install
+
+```sh
+pip install open-langchain
+# or: uv add open-langchain
+```
+
+## Usage
+
+`create_chat` routes the supported native providers:
+
+```python
+from open_langchain import create_chat
+
+codex = create_chat("openai-codex", "gpt-5.3-codex-spark")
+claude = create_chat("claude-code", "claude-sonnet-4-6")
+free = create_chat("opencode", "deepseek-v4-flash-free")
+go = create_chat("opencode-go", "glm-5", api_key="...")
+```
+
+Or construct Codex directly:
+
+```python
+from open_langchain import ChatCodex
+
+model = ChatCodex(
+    model="gpt-5.3-codex-spark",
+    reasoning="minimal",
+    system="You are a helpful assistant.",
+)
+
+print(model.invoke("Hello!").content)
+```
+
+## Codex Auth
+
+`ChatCodex` reads the same `~/.pi/agent/auth.json` credential shape under
+`openai-codex`, refreshes the OAuth token in place, and talks directly to
+`https://chatgpt.com/backend-api/codex/responses`.
+
+If no credential exists:
+
+```sh
+codex-login
+codex-login --device
+```
+
+## Tool Calling
+
+```python
+from langchain_core.tools import tool
+from open_langchain import ChatCodex
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"It is sunny in {city}, 24C."
+
+model = ChatCodex(model="gpt-5.3-codex").bind_tools([get_weather])
+msg = model.invoke("What's the weather in Paris?")
+print(msg.tool_calls)
+```
+
+`tool_choice` is passed through to the Codex Responses API:
+
+```python
+forced = ChatCodex(model="gpt-5.3-codex").bind_tools(
+    [get_weather],
+    tool_choice={"type": "function", "name": "get_weather"},
+)
+```
+
+For agent loops, keep `tool_choice="auto"` unless every model turn should call the
+same tool.
+
+## Streaming
+
+```python
+for chunk in model.stream("Write a haiku."):
+    print(chunk.content, end="")
+```
+
+## OpenCode
+
+`ChatOpencode` uses OpenCode's OpenAI-compatible endpoints through
+`langchain-openai`.
+
+```python
+from open_langchain import ChatOpencode
+
+free = ChatOpencode("deepseek-v4-flash-free")
+paid = ChatOpencode("glm-5")
+go = ChatOpencode("glm-5", tier="go")
+```
+
+Free models include `deepseek-v4-flash-free`, `big-pickle`, `mimo-v2.5-free`, and
+`nemotron-3-super-free`.
+
+## Claude Code (Anthropic subscription)
+
+`ChatClaudeCode` talks to the Anthropic Messages API authenticated with the
+Claude Code OAuth session already on the machine (`~/.claude/.credentials.json`),
+billing requests against your Claude Code subscription — no API key. It reads and
+refreshes the token in place (with a `claude` CLI fallback).
+
+```python
+from open_langchain import ChatClaudeCode, create_chat
+
+chat = create_chat("claude-code", "claude-sonnet-4-6")
+print(chat.invoke("Hello!").content)
+
+# Or construct directly, with options:
+opus = ChatClaudeCode(model="claude-opus-4-8", reasoning="medium")
+```
+
+Models: `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-4-6`,
+`claude-haiku-4-5`. Reasoning uses adaptive thinking on Opus 4.8/4.7 and a token
+budget on Sonnet 4.6 (Haiku has no reasoning). The 1M-context beta is **opt-in**
+via `long_context=True`; the subscription rejects long-context requests without
+extra credits otherwise. Tool calling and streaming work as with `ChatCodex`.
+
+> Using a subscription OAuth session from a third-party app may violate
+> Anthropic's terms and risk your account. See the
+> [`pi-claude-code-auth`](https://github.com/cgaravitoq/pi-claude-code-auth)
+> README before relying on this.
+
+## License
+
+MIT

open_langchain-0.6.1/README.md

@@ -0,0 +1,143 @@
+# open-langchain
+
+Native LangChain chat models for **OpenAI Codex** (ChatGPT Plus/Pro
+subscription OAuth), **Claude** (Claude Code subscription OAuth), and
+**OpenCode Zen/Go**. No Pi runtime, no Node sidecar.
+
+## Requirements
+
+- Python >= 3.9
+- For Codex: an `openai-codex` credential in `~/.pi/agent/auth.json`, or sign in
+  with `codex-login`
+- For Claude Code: the Claude Code CLI logged in once (`~/.claude/.credentials.json`)
+- For paid OpenCode models: `OPENCODE_API_KEY` or an explicit `api_key`
+
+## Install
+
+```sh
+pip install open-langchain
+# or: uv add open-langchain
+```
+
+## Usage
+
+`create_chat` routes the supported native providers:
+
+```python
+from open_langchain import create_chat
+
+codex = create_chat("openai-codex", "gpt-5.3-codex-spark")
+claude = create_chat("claude-code", "claude-sonnet-4-6")
+free = create_chat("opencode", "deepseek-v4-flash-free")
+go = create_chat("opencode-go", "glm-5", api_key="...")
+```
+
+Or construct Codex directly:
+
+```python
+from open_langchain import ChatCodex
+
+model = ChatCodex(
+    model="gpt-5.3-codex-spark",
+    reasoning="minimal",
+    system="You are a helpful assistant.",
+)
+
+print(model.invoke("Hello!").content)
+```
+
+## Codex Auth
+
+`ChatCodex` reads the same `~/.pi/agent/auth.json` credential shape under
+`openai-codex`, refreshes the OAuth token in place, and talks directly to
+`https://chatgpt.com/backend-api/codex/responses`.
+
+If no credential exists:
+
+```sh
+codex-login
+codex-login --device
+```
+
+## Tool Calling
+
+```python
+from langchain_core.tools import tool
+from open_langchain import ChatCodex
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"It is sunny in {city}, 24C."
+
+model = ChatCodex(model="gpt-5.3-codex").bind_tools([get_weather])
+msg = model.invoke("What's the weather in Paris?")
+print(msg.tool_calls)
+```
+
+`tool_choice` is passed through to the Codex Responses API:
+
+```python
+forced = ChatCodex(model="gpt-5.3-codex").bind_tools(
+    [get_weather],
+    tool_choice={"type": "function", "name": "get_weather"},
+)
+```
+
+For agent loops, keep `tool_choice="auto"` unless every model turn should call the
+same tool.
+
+## Streaming
+
+```python
+for chunk in model.stream("Write a haiku."):
+    print(chunk.content, end="")
+```
+
+## OpenCode
+
+`ChatOpencode` uses OpenCode's OpenAI-compatible endpoints through
+`langchain-openai`.
+
+```python
+from open_langchain import ChatOpencode
+
+free = ChatOpencode("deepseek-v4-flash-free")
+paid = ChatOpencode("glm-5")
+go = ChatOpencode("glm-5", tier="go")
+```
+
+Free models include `deepseek-v4-flash-free`, `big-pickle`, `mimo-v2.5-free`, and
+`nemotron-3-super-free`.
+
+## Claude Code (Anthropic subscription)
+
+`ChatClaudeCode` talks to the Anthropic Messages API authenticated with the
+Claude Code OAuth session already on the machine (`~/.claude/.credentials.json`),
+billing requests against your Claude Code subscription — no API key. It reads and
+refreshes the token in place (with a `claude` CLI fallback).
+
+```python
+from open_langchain import ChatClaudeCode, create_chat
+
+chat = create_chat("claude-code", "claude-sonnet-4-6")
+print(chat.invoke("Hello!").content)
+
+# Or construct directly, with options:
+opus = ChatClaudeCode(model="claude-opus-4-8", reasoning="medium")
+```
+
+Models: `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-4-6`,
+`claude-haiku-4-5`. Reasoning uses adaptive thinking on Opus 4.8/4.7 and a token
+budget on Sonnet 4.6 (Haiku has no reasoning). The 1M-context beta is **opt-in**
+via `long_context=True`; the subscription rejects long-context requests without
+extra credits otherwise. Tool calling and streaming work as with `ChatCodex`.
+
+> Using a subscription OAuth session from a third-party app may violate
+> Anthropic's terms and risk your account. See the
+> [`pi-claude-code-auth`](https://github.com/cgaravitoq/pi-claude-code-auth)
+> README before relying on this.
+
+## License
+
+MIT

open_langchain-0.6.1/btca.config.jsonc

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://btca.dev/btca.schema.json",
+  "dataDirectory": ".btca",
+  "resources": [
+    {
+      "name": "open-langchain",
+      "type": "git",
+      "url": "https://github.com/cgaravitoq/open-langchain",
+      "branch": "main",
+      "specialNotes": "This repo (to be renamed open-langchain): native LangChain chat models in Python, no Pi sidecar. ChatCodex (auth.py, client.py, codex_conversions.py, models.py, chat_models.py), ChatClaudeCode (claude_code_*.py), ChatOpencode (opencode.py). Reverse-engineered OAuth + Anthropic billing signing live in claude_code_signing.py and auth.py."
+    },
+    {
+      "name": "open-langchain-ts",
+      "type": "git",
+      "url": "https://github.com/cgaravitoq/open-langchain-ts",
+      "branch": "main",
+      "specialNotes": "TypeScript twin (to be renamed open-langchain-ts). The Codex path here was ported FROM this Python repo; keep both in sync when the Codex responses API or OpenAI/Anthropic OAuth flow changes."
+    },
+    {
+      "name": "opencode-claude-auth",
+      "type": "git",
+      "url": "https://github.com/griffinmartin/opencode-claude-auth",
+      "branch": "main",
+      "specialNotes": "Upstream origin of the Claude Code OAuth + payload-transform logic mirrored in claude_code_*.py. Re-read when Claude Code changes its billing header, betas, or refresh flow."
+    }
+  ]
+}

open_langchain-0.6.1/open_langchain/__init__.py

@@ -0,0 +1,21 @@
+from .auth import CodexAuth, CodexAuthError
+from .chat_models import ChatCodex
+from .claude_code_auth import ClaudeCodeAuth, ClaudeCodeAuthError
+from .claude_code_chat_models import ChatClaudeCode
+from .claude_code_models import CLAUDE_CODE_MODELS
+from .factory import create_chat
+from .models import OPENAI_CODEX_MODELS
+from .opencode import ChatOpencode
+
+__all__ = [
+    "ChatCodex",
+    "ChatClaudeCode",
+    "ChatOpencode",
+    "CodexAuth",
+    "CodexAuthError",
+    "ClaudeCodeAuth",
+    "ClaudeCodeAuthError",
+    "CLAUDE_CODE_MODELS",
+    "OPENAI_CODEX_MODELS",
+    "create_chat",
+]

open_langchain-0.6.1/open_langchain/auth.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from .constants import (
+    CLIENT_ID,
+    JWT_CLAIM_PATH,
+    PROVIDER_ID,
+    REFRESH_TIMEOUT,
+    TOKEN_URL,
+)
+
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - non-POSIX
+    fcntl = None  # type: ignore[assignment]
+
+
+class CodexAuthError(Exception):
+    """Raised when no usable openai-codex credential is available."""
+
+
+def _decode_jwt_payload(token: str) -> Optional[dict]:
+    parts = token.split(".")
+    if len(parts) != 3:
+        return None
+    payload = parts[1]
+    payload += "=" * (-len(payload) % 4)
+    try:
+        raw = base64.urlsafe_b64decode(payload.encode())
+        return json.loads(raw)
+    except Exception:
+        return None
+
+
+def extract_account_id(access_token: str) -> Optional[str]:
+    payload = _decode_jwt_payload(access_token)
+    if not payload:
+        return None
+    auth = payload.get(JWT_CLAIM_PATH)
+    if not isinstance(auth, dict):
+        return None
+    account_id = auth.get("chatgpt_account_id")
+    if isinstance(account_id, str) and account_id:
+        return account_id
+    return None
+
+
+def resolve_auth_path(explicit: Optional[str] = None) -> Path:
+    if explicit:
+        return Path(explicit).expanduser()
+    agent_dir = os.environ.get("PI_CODING_AGENT_DIR")
+    if agent_dir:
+        return Path(agent_dir).expanduser() / "auth.json"
+    config_dir = os.environ.get("PI_CONFIG_DIR_NAME", ".pi")
+    return Path.home() / config_dir / "agent" / "auth.json"
+
+
+class CodexAuth:
+    def __init__(self, auth_path: Optional[str] = None) -> None:
+        self.path = resolve_auth_path(auth_path)
+
+    def load(self) -> dict:
+        if not self.path.exists():
+            raise CodexAuthError(
+                f"No auth.json found at {self.path}. Run `codex-login` to sign in."
+            )
+        return json.loads(self.path.read_text())
+
+    def get_credential(self) -> dict:
+        credentials = self.load()
+        entry = credentials.get(PROVIDER_ID)
+        if not entry:
+            raise CodexAuthError(
+                f"No `{PROVIDER_ID}` credential in {self.path}. "
+                "Run `codex-login` to sign in with your ChatGPT subscription."
+            )
+        return entry
+
+    def get_access_token(self) -> dict:
+        credential = self.get_credential()
+        now_ms = int(time.time() * 1000)
+        if now_ms >= int(credential.get("expires", 0)):
+            credential = self.refresh()
+        return credential
+
+    def account_id(self, credential: Optional[dict] = None) -> str:
+        credential = credential or self.get_credential()
+        stored = credential.get("accountId")
+        if isinstance(stored, str) and stored:
+            return stored
+        account_id = extract_account_id(credential.get("access", ""))
+        if not account_id:
+            raise CodexAuthError("Failed to extract accountId from token")
+        return account_id
+
+    def refresh(self) -> dict:
+        credentials = self.load()
+        entry = credentials.get(PROVIDER_ID)
+        if not entry:
+            raise CodexAuthError(
+                f"No `{PROVIDER_ID}` credential in {self.path}. Run `codex-login`."
+            )
+        response = httpx.post(
+            TOKEN_URL,
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": entry["refresh"],
+                "client_id": CLIENT_ID,
+            },
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            timeout=REFRESH_TIMEOUT,
+        )
+        if response.status_code >= 400:
+            raise CodexAuthError(
+                f"OpenAI Codex token refresh failed ({response.status_code}): "
+                f"{response.text}"
+            )
+        data = response.json()
+        access = data.get("access_token")
+        refresh_token = data.get("refresh_token")
+        expires_in = data.get("expires_in")
+        if not access or not refresh_token or not isinstance(expires_in, (int, float)):
+            raise CodexAuthError("Token refresh response missing fields")
+        credential = {
+            "type": "oauth",
+            "access": access,
+            "refresh": refresh_token,
+            "expires": int(time.time() * 1000) + int(expires_in) * 1000,
+            "accountId": extract_account_id(access),
+        }
+        credentials[PROVIDER_ID] = credential
+        self._write(credentials)
+        return credential
+
+    def write_credential(self, credential: dict) -> None:
+        try:
+            credentials = self.load()
+        except CodexAuthError:
+            credentials = {}
+        credentials[PROVIDER_ID] = {"type": "oauth", **credential}
+        self._write(credentials)
+
+    def _write(self, credentials: dict) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        os.chmod(self.path.parent, 0o700)
+        lock_path = self.path.with_name(self.path.name + ".lock")
+        lock_file = open(lock_path, "w")
+        try:
+            if fcntl is not None:
+                try:
+                    fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+                except OSError:
+                    pass
+            self.path.write_text(json.dumps(credentials, indent=2))
+            os.chmod(self.path, 0o600)
+        finally:
+            if fcntl is not None:
+                try:
+                    fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+                except OSError:
+                    pass
+            lock_file.close()
+            try:
+                lock_path.unlink()
+            except OSError:
+                pass