thinchat 0.1.0__tar.gz

thinchat-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling caches
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+
+# AI coding agents
+CLAUDE.md
+.claude/
+AGENTS.md
+AGENT.md
+.codex/
+GEMINI.md
+.gemini/
+
+dev/

thinchat-0.1.0/LICENSE

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

thinchat-0.1.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: thinchat
+Version: 0.1.0
+Summary: A tiny, unified client for four LLM providers: claude, openai, gemini, ollama.
+Project-URL: Homepage, https://github.com/seokhoonj/thinchat
+Project-URL: Repository, https://github.com/seokhoonj/thinchat
+Project-URL: Issues, https://github.com/seokhoonj/thinchat/issues
+Author-email: seokhoonj <seokhoonj@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: claude,completion,embeddings,gemini,llm,ollama,openai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.40
+Requires-Dist: httpx>=0.23
+Requires-Dist: openai>=1.30
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# thinchat
+
+**English** | [한국어](README.ko.md)
+
+A tiny, unified client for four LLM providers — **claude, openai, gemini, ollama**.
+
+Name a provider, then call it. Every client offers completion — whole, streamed, or
+JSON-structured — and, where the provider has one, embeddings, each with an async twin. No
+gateway, no router, no cost tracking: just the calls, over the providers' own SDKs.
+
+## How it works
+
+```mermaid
+flowchart LR
+  M["make_client(provider)"] --> C["Client<br/>openai-compatible · or claude"]
+  C --> V["complete · stream · parse · embed<br/>(+ a-prefixed async twins)"]
+  V --> S{{"vendor SDK"}}
+  S -->|ok| O(["str · dict · list float · stream"])
+  S -->|"SDK / transport error"| E(["LLMError"])
+```
+
+`make_client` looks the provider up in one factory map: openai/gemini/ollama share a single
+class over the openai SDK (they differ only in data); claude has its own over anthropic.
+A call builds the request, hits the SDK, and either extracts the reply or maps the failure
+to one `LLMError`.
+
+## Install
+
+```sh
+pip install thinchat
+```
+
+Both provider SDKs (openai and anthropic) come with it, so every provider works out of the
+box; each is imported lazily the first time you construct its client.
+
+## Use
+
+```python
+from thinchat import make_client
+
+llm = make_client("claude")                     # key from CLAUDE_API_KEY
+print(llm.complete("Say hi in one word."))
+print(llm.complete("Name a color.", system="Answer in one word."))   # system= steers any verb
+
+# Structured output: reply parsed into a JSON object. The schema steers generation
+# but is not validated locally, so check the returned dict's fields yourself.
+verdict = llm.parse(
+    "Is this an ad? 'Buy now, 50% off — order today'",
+    schema={"type": "object",
+            "properties": {"is_ad": {"type": "boolean"}, "reason": {"type": "string"}},
+            "required": ["is_ad"]},
+)
+print(verdict["is_ad"])
+
+# Streaming.
+for chunk in make_client("claude").stream("Count to five."):
+    print(chunk, end="")
+
+# Embeddings (openai / gemini / ollama; Claude has none).
+vectors = make_client("openai").embed(["hello", "world"])
+```
+
+Every verb has an async twin — `acomplete`, `astream`, `aparse`, `aembed`:
+
+```python
+llm = make_client("claude")
+text = await llm.acomplete("Summarize in one line: ...")
+```
+
+## Providers
+
+| provider | key env           | embeddings |
+|----------|-------------------|------------|
+| `claude` | `CLAUDE_API_KEY`  | no         |
+| `openai` | `OPENAI_API_KEY`  | yes        |
+| `gemini` | `GEMINI_API_KEY`  | yes        |
+| `ollama` | none (local)      | yes        |
+
+openai, gemini, and ollama speak the same OpenAI-compatible API, so one SDK serves all
+three; only the base URL, key, and default models differ. Ollama runs locally
+(`OLLAMA_HOST`, default `http://localhost:11434`) and needs no key.
+
+`max_tokens` caps the reply length — `make_client("claude", max_tokens=8192)`. Anthropic
+requires the field, so claude defaults to 4096; the OpenAI-compatible providers omit it unless
+you pass one, letting the model decide.
+
+Keys are read from the environment. Set them once in your shell profile (`~/.bashrc`,
+`~/.zshrc`) so every session picks them up — thinchat is a library and never imposes a file
+location of its own:
+
+```sh
+export CLAUDE_API_KEY="sk-ant-..."
+export OPENAI_API_KEY="sk-..."
+export GEMINI_API_KEY="..."          # ollama runs locally and needs no key
+```
+
+Or pass a key explicitly, which overrides the environment:
+
+```python
+llm = make_client("claude", api_key="sk-ant-...", model="claude-haiku-4-5-20251001")
+```
+
+## Capabilities
+
+A client whose provider lacks a capability raises `UnsupportedError`. The capabilities are
+`completion`, `streaming`, `structured_output`, and `embeddings`; check first with `supports`:
+
+```python
+make_client("claude").supports("embeddings")   # False
+```
+
+## Errors
+
+Everything thinchat raises on purpose derives from `ThinchatError`, so one `except` handles
+the package's failures:
+
+- `UnknownProviderError` — the name isn't one of the four providers.
+- `ProviderUnavailableError` — the provider's SDK isn't installed, or no API key is set.
+- `UnsupportedError` — the provider lacks the capability (e.g. embeddings on Claude).
+- `LLMError` — the API call failed, or the reply was empty or malformed.
+
+## Lifecycle
+
+A client holds an HTTP connection pool. For a one-off script you can ignore it; for a
+server that builds a client per request, close it so connections do not leak — use it as a
+context manager, or call `close()` / `aclose()`:
+
+```python
+with make_client("claude") as llm:
+    llm.complete("...")                 # sync: closes the pool on exit
+
+async with make_client("claude") as llm:
+    await llm.acomplete("...")          # async: closes the async pool too
+```
+
+`close()` frees the sync pool; if you drove async verbs, release with `aclose()` or
+`async with` so the async pool is closed as well.
+
+## License
+
+MIT

thinchat-0.1.0/README.ko.md

@@ -0,0 +1,139 @@
+# thinchat
+
+[English](README.md) | **한국어**
+
+네 개의 LLM provider — **claude, openai, gemini, ollama** — 를 위한 작고 통일된 클라이언트.
+
+provider 이름만 대면 호출됩니다. 모든 클라이언트가 completion(전체·스트리밍·JSON 구조화)을
+제공하고, provider가 지원하면 embeddings도 제공하며, 각각 async 짝이 있습니다. gateway도,
+router도, 비용 추적도 없이 — provider 자신의 SDK 위에서 호출만 합니다.
+
+## 동작 방식
+
+```mermaid
+flowchart LR
+  M["make_client(provider)"] --> C["Client<br/>openai-compatible · or claude"]
+  C --> V["complete · stream · parse · embed<br/>(+ a-prefixed async twins)"]
+  V --> S{{"vendor SDK"}}
+  S -->|ok| O(["str · dict · list float · stream"])
+  S -->|"SDK / transport error"| E(["LLMError"])
+```
+
+`make_client`는 provider를 하나의 factory map에서 찾습니다: openai/gemini/ollama는 openai
+SDK 위의 단일 클래스를 공유하고(데이터만 다름), claude는 anthropic 위에 자기 것을 둡니다.
+호출은 요청을 조립해 SDK를 치고, 응답을 추출하거나 실패를 하나의 `LLMError`로 매핑합니다.
+
+## 설치
+
+```sh
+pip install thinchat
+```
+
+두 provider SDK(openai와 anthropic)가 함께 설치되어 모든 provider가 바로 동작합니다. 각 SDK는
+해당 클라이언트를 처음 생성할 때 lazy하게 import됩니다.
+
+## 사용
+
+```python
+from thinchat import make_client
+
+llm = make_client("claude")                     # 키는 CLAUDE_API_KEY에서
+print(llm.complete("Say hi in one word."))
+print(llm.complete("Name a color.", system="Answer in one word."))   # system=은 모든 verb를 유도
+
+# 구조화 출력: 응답을 JSON 객체로 파싱. schema는 생성을 유도할 뿐 로컬에서 검증하지 않으므로,
+# 반환된 dict의 필드는 직접 확인하세요.
+verdict = llm.parse(
+    "Is this an ad? 'Buy now, 50% off — order today'",
+    schema={"type": "object",
+            "properties": {"is_ad": {"type": "boolean"}, "reason": {"type": "string"}},
+            "required": ["is_ad"]},
+)
+print(verdict["is_ad"])
+
+# 스트리밍.
+for chunk in make_client("claude").stream("Count to five."):
+    print(chunk, end="")
+
+# 임베딩 (openai / gemini / ollama; Claude는 없음).
+vectors = make_client("openai").embed(["hello", "world"])
+```
+
+모든 verb에는 async 짝이 있습니다 — `acomplete`, `astream`, `aparse`, `aembed`:
+
+```python
+llm = make_client("claude")
+text = await llm.acomplete("Summarize in one line: ...")
+```
+
+## Provider
+
+| provider | 키 환경변수        | embeddings |
+|----------|-------------------|------------|
+| `claude` | `CLAUDE_API_KEY`  | 아니오     |
+| `openai` | `OPENAI_API_KEY`  | 예         |
+| `gemini` | `GEMINI_API_KEY`  | 예         |
+| `ollama` | 없음 (로컬)        | 예         |
+
+openai, gemini, ollama는 동일한 OpenAI 호환 API를 쓰므로 하나의 SDK가 셋을 다 처리하고, base
+URL·키·기본 모델만 다릅니다. Ollama는 로컬에서 실행되며(`OLLAMA_HOST`, 기본
+`http://localhost:11434`) 키가 필요 없습니다.
+
+`max_tokens`는 응답 길이의 상한입니다 — `make_client("claude", max_tokens=8192)`. Anthropic은
+이 필드를 요구하므로 claude는 기본값 4096을 쓰고, OpenAI 호환 provider들은 값을 주지 않으면
+생략해 모델이 정하게 둡니다.
+
+키는 환경에서 읽습니다. 셸 프로파일(`~/.bashrc`, `~/.zshrc`)에 한 번 넣어두면 모든 세션이
+인식합니다 — thinchat은 라이브러리라 자체 파일 위치를 강제하지 않습니다:
+
+```sh
+export CLAUDE_API_KEY="sk-ant-..."
+export OPENAI_API_KEY="sk-..."
+export GEMINI_API_KEY="..."          # ollama는 로컬이라 키 불필요
+```
+
+또는 환경변수를 덮어쓰며 키를 직접 넘길 수도 있습니다:
+
+```python
+llm = make_client("claude", api_key="sk-ant-...", model="claude-haiku-4-5-20251001")
+```
+
+## 지원 기능(Capabilities)
+
+provider가 지원하지 않는 기능을 호출하면 `UnsupportedError`가 발생합니다. 기능은 `completion`,
+`streaming`, `structured_output`, `embeddings`이며, `supports`로 먼저 확인하세요:
+
+```python
+make_client("claude").supports("embeddings")   # False
+```
+
+## 에러
+
+thinchat이 의도적으로 던지는 모든 에러는 `ThinchatError`에서 파생되므로, 하나의 `except`로 이
+패키지의 실패를 처리할 수 있습니다:
+
+- `UnknownProviderError` — 이름이 네 provider 중 하나가 아님.
+- `ProviderUnavailableError` — provider의 SDK가 설치되지 않았거나, API 키가 없음.
+- `UnsupportedError` — provider가 그 기능을 지원하지 않음(예: Claude의 embeddings).
+- `LLMError` — API 호출이 실패했거나, 응답이 비었거나 형식이 잘못됨.
+
+## 생명주기(Lifecycle)
+
+클라이언트는 HTTP 연결 풀을 보유합니다. 일회성 스크립트라면 신경 쓰지 않아도 되지만, 요청마다
+클라이언트를 만드는 서버라면 연결이 새지 않도록 닫아야 합니다 — context manager로 쓰거나
+`close()` / `aclose()`를 호출하세요:
+
+```python
+with make_client("claude") as llm:
+    llm.complete("...")                 # 동기: 종료 시 풀을 닫음
+
+async with make_client("claude") as llm:
+    await llm.acomplete("...")          # 비동기: async 풀도 닫음
+```
+
+`close()`는 동기 풀을 해제합니다. async verb를 사용했다면 `aclose()`나 `async with`로 async
+풀까지 닫으세요.
+
+## 라이선스
+
+MIT

thinchat-0.1.0/README.md

@@ -0,0 +1,141 @@
+# thinchat
+
+**English** | [한국어](README.ko.md)
+
+A tiny, unified client for four LLM providers — **claude, openai, gemini, ollama**.
+
+Name a provider, then call it. Every client offers completion — whole, streamed, or
+JSON-structured — and, where the provider has one, embeddings, each with an async twin. No
+gateway, no router, no cost tracking: just the calls, over the providers' own SDKs.
+
+## How it works
+
+```mermaid
+flowchart LR
+  M["make_client(provider)"] --> C["Client<br/>openai-compatible · or claude"]
+  C --> V["complete · stream · parse · embed<br/>(+ a-prefixed async twins)"]
+  V --> S{{"vendor SDK"}}
+  S -->|ok| O(["str · dict · list float · stream"])
+  S -->|"SDK / transport error"| E(["LLMError"])
+```
+
+`make_client` looks the provider up in one factory map: openai/gemini/ollama share a single
+class over the openai SDK (they differ only in data); claude has its own over anthropic.
+A call builds the request, hits the SDK, and either extracts the reply or maps the failure
+to one `LLMError`.
+
+## Install
+
+```sh
+pip install thinchat
+```
+
+Both provider SDKs (openai and anthropic) come with it, so every provider works out of the
+box; each is imported lazily the first time you construct its client.
+
+## Use
+
+```python
+from thinchat import make_client
+
+llm = make_client("claude")                     # key from CLAUDE_API_KEY
+print(llm.complete("Say hi in one word."))
+print(llm.complete("Name a color.", system="Answer in one word."))   # system= steers any verb
+
+# Structured output: reply parsed into a JSON object. The schema steers generation
+# but is not validated locally, so check the returned dict's fields yourself.
+verdict = llm.parse(
+    "Is this an ad? 'Buy now, 50% off — order today'",
+    schema={"type": "object",
+            "properties": {"is_ad": {"type": "boolean"}, "reason": {"type": "string"}},
+            "required": ["is_ad"]},
+)
+print(verdict["is_ad"])
+
+# Streaming.
+for chunk in make_client("claude").stream("Count to five."):
+    print(chunk, end="")
+
+# Embeddings (openai / gemini / ollama; Claude has none).
+vectors = make_client("openai").embed(["hello", "world"])
+```
+
+Every verb has an async twin — `acomplete`, `astream`, `aparse`, `aembed`:
+
+```python
+llm = make_client("claude")
+text = await llm.acomplete("Summarize in one line: ...")
+```
+
+## Providers
+
+| provider | key env           | embeddings |
+|----------|-------------------|------------|
+| `claude` | `CLAUDE_API_KEY`  | no         |
+| `openai` | `OPENAI_API_KEY`  | yes        |
+| `gemini` | `GEMINI_API_KEY`  | yes        |
+| `ollama` | none (local)      | yes        |
+
+openai, gemini, and ollama speak the same OpenAI-compatible API, so one SDK serves all
+three; only the base URL, key, and default models differ. Ollama runs locally
+(`OLLAMA_HOST`, default `http://localhost:11434`) and needs no key.
+
+`max_tokens` caps the reply length — `make_client("claude", max_tokens=8192)`. Anthropic
+requires the field, so claude defaults to 4096; the OpenAI-compatible providers omit it unless
+you pass one, letting the model decide.
+
+Keys are read from the environment. Set them once in your shell profile (`~/.bashrc`,
+`~/.zshrc`) so every session picks them up — thinchat is a library and never imposes a file
+location of its own:
+
+```sh
+export CLAUDE_API_KEY="sk-ant-..."
+export OPENAI_API_KEY="sk-..."
+export GEMINI_API_KEY="..."          # ollama runs locally and needs no key
+```
+
+Or pass a key explicitly, which overrides the environment:
+
+```python
+llm = make_client("claude", api_key="sk-ant-...", model="claude-haiku-4-5-20251001")
+```
+
+## Capabilities
+
+A client whose provider lacks a capability raises `UnsupportedError`. The capabilities are
+`completion`, `streaming`, `structured_output`, and `embeddings`; check first with `supports`:
+
+```python
+make_client("claude").supports("embeddings")   # False
+```
+
+## Errors
+
+Everything thinchat raises on purpose derives from `ThinchatError`, so one `except` handles
+the package's failures:
+
+- `UnknownProviderError` — the name isn't one of the four providers.
+- `ProviderUnavailableError` — the provider's SDK isn't installed, or no API key is set.
+- `UnsupportedError` — the provider lacks the capability (e.g. embeddings on Claude).
+- `LLMError` — the API call failed, or the reply was empty or malformed.
+
+## Lifecycle
+
+A client holds an HTTP connection pool. For a one-off script you can ignore it; for a
+server that builds a client per request, close it so connections do not leak — use it as a
+context manager, or call `close()` / `aclose()`:
+
+```python
+with make_client("claude") as llm:
+    llm.complete("...")                 # sync: closes the pool on exit
+
+async with make_client("claude") as llm:
+    await llm.acomplete("...")          # async: closes the async pool too
+```
+
+`close()` frees the sync pool; if you drove async verbs, release with `aclose()` or
+`async with` so the async pool is closed as well.
+
+## License
+
+MIT

thinchat-0.1.0/pyproject.toml

@@ -0,0 +1,82 @@
+[build-system]
+requires      = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name            = "thinchat"
+version         = "0.1.0"
+description     = "A tiny, unified client for four LLM providers: claude, openai, gemini, ollama."
+readme          = "README.md"
+license         = "MIT"
+license-files   = ["LICENSE"]
+authors         = [{ name = "seokhoonj", email = "seokhoonj@gmail.com" }]
+keywords        = ["llm", "openai", "claude", "gemini", "ollama", "completion", "embeddings"]
+classifiers     = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+# 3.11+ for the typing niceties this package uses (e.g. Self).
+requires-python = ">=3.11"
+# openai, gemini, and ollama speak the OpenAI-compatible API, so the openai SDK powers
+# three providers; claude uses the anthropic SDK. Both ship with the base install, so a
+# plain `pip install thinchat` is ready for every provider -- each SDK is still imported
+# lazily, only when its client is constructed. httpx is named directly (its transport
+# errors are caught on the streaming path), so it is a direct dependency, not a transitive.
+dependencies    = [
+    "openai>=1.30",
+    "anthropic>=0.40",
+    "httpx>=0.23",
+]
+
+[project.urls]
+Homepage   = "https://github.com/seokhoonj/thinchat"
+Repository = "https://github.com/seokhoonj/thinchat"
+Issues     = "https://github.com/seokhoonj/thinchat/issues"
+
+[project.optional-dependencies]
+# Development only; the provider SDKs are base dependencies, installed with the package.
+dev = [
+    "mypy>=1.11",
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "ruff>=0.6",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/thinchat"]
+
+[tool.ruff]
+line-length    = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.11"
+files = ["src", "tests"]
+strict = true
+
+# The provider SDKs are optional extras, imported lazily and absent from a minimal
+# environment, so mypy cannot see them -- and must not need to: the package type-checks
+# without them.
+[[tool.mypy.overrides]]
+module = ["openai", "openai.*", "anthropic", "anthropic.*"]
+ignore_missing_imports = true
+
+# Tests get the real checks but not the annotation ceremony: `-> None` on every test
+# function is noise, and a test's signature is never the thing under review.
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+disallow_untyped_calls = false
+check_untyped_defs = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

thinchat-0.1.0/src/thinchat/__init__.py

@@ -0,0 +1,51 @@
+"""thinchat: a tiny, unified client for four LLM providers -- claude, openai, gemini, ollama.
+
+Name a provider, then call it. Each client offers completion (whole, streamed, or
+JSON-structured) and, where the provider has one, embeddings -- with an async twin for each.
+
+    from thinchat import make_client
+
+    llm = make_client("claude")                 # key from CLAUDE_API_KEY
+    print(llm.complete("Say hi in one word."))
+    verdict = llm.parse("Is this an ad? 'Buy now, 50% off'",
+                        schema={"type": "object",
+                                "properties": {"is_ad": {"type": "boolean"}},
+                                "required": ["is_ad"]})
+
+Installing thinchat brings both provider SDKs (openai and anthropic), so every provider
+works out of the box; each SDK is imported lazily when you first construct its client.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from thinchat.claude_client import ClaudeClient
+from thinchat.client import Capability, Client, Provider
+from thinchat.errors import (
+    LLMError,
+    ProviderUnavailableError,
+    ThinchatError,
+    UnknownProviderError,
+    UnsupportedError,
+)
+from thinchat.openai_client import OpenAICompatibleClient
+from thinchat.providers import PROVIDERS, make_client
+
+__all__ = [
+    "PROVIDERS",
+    "Capability",
+    "ClaudeClient",
+    "Client",
+    "LLMError",
+    "OpenAICompatibleClient",
+    "Provider",
+    "ProviderUnavailableError",
+    "ThinchatError",
+    "UnknownProviderError",
+    "UnsupportedError",
+    "make_client",
+]
+
+try:
+    __version__ = version("thinchat")   # single source of truth: the installed metadata
+except PackageNotFoundError:            # running from a source tree that was never installed
+    __version__ = "0.0.0+unknown"