nous-genai 0.1.0__py3-none-any.whl

nous/genai/types.py

@@ -0,0 +1,416 @@
+from __future__ import annotations
+
+import base64
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal, cast
+
+from ._internal.errors import ErrorInfo, invalid_request_error, not_supported_error
+
+Role = Literal["system", "user", "assistant", "tool"]
+PartType = Literal[
+    "text",
+    "image",
+    "audio",
+    "video",
+    "embedding",
+    "file",
+    "tool_call",
+    "tool_result",
+]
+
+Modality = Literal["text", "image", "audio", "video", "embedding"]
+Status = Literal["completed", "running", "failed", "canceled"]
+ReasoningEffort = Literal["none", "minimal", "low", "medium", "high", "xhigh"]
+ToolChoiceMode = Literal["none", "auto", "required", "tool"]
+
+
+@dataclass(frozen=True, slots=True)
+class ReasoningSpec:
+    effort: ReasoningEffort | None = None
+
+
+_REASONING_EFFORT_VALUES = {"none", "minimal", "low", "medium", "high", "xhigh"}
+
+
+def normalize_reasoning_effort(value: object) -> ReasoningEffort:
+    if not isinstance(value, str) or not value.strip():
+        raise invalid_request_error("reasoning.effort must be a non-empty string")
+    effort = value.strip().lower()
+    if effort not in _REASONING_EFFORT_VALUES:
+        raise invalid_request_error(f"unknown reasoning.effort: {effort}")
+    return cast(ReasoningEffort, effort)
+
+
+@dataclass(frozen=True, slots=True)
+class PartSourceBytes:
+    kind: Literal["bytes"] = "bytes"
+    data: bytes | str = b""
+    encoding: Literal["base64"] | None = None
+
+    def __post_init__(self) -> None:
+        if self.encoding is None:
+            if isinstance(self.data, bytearray):
+                object.__setattr__(self, "data", bytes(self.data))
+                return
+            if not isinstance(self.data, bytes):
+                raise ValueError(
+                    "PartSourceBytes.data must be bytes when encoding is None"
+                )
+            return
+
+        if self.encoding != "base64":
+            raise ValueError(f"unknown PartSourceBytes.encoding: {self.encoding}")
+        if not isinstance(self.data, str):
+            raise ValueError(
+                "PartSourceBytes.data must be str when encoding is 'base64'"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class PartSourcePath:
+    kind: Literal["path"] = "path"
+    path: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class PartSourceUrl:
+    kind: Literal["url"] = "url"
+    url: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class PartSourceRef:
+    kind: Literal["ref"] = "ref"
+    provider: str = ""
+    id: str = ""
+
+
+PartSource = PartSourceBytes | PartSourcePath | PartSourceUrl | PartSourceRef
+
+
+@dataclass(frozen=True, slots=True)
+class Part:
+    type: PartType
+    mime_type: str | None = None
+    source: PartSource | None = None
+    text: str | None = None
+    embedding: list[float] | None = None
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.meta, dict):
+            raise ValueError("Part.meta must be an object")
+        if self.mime_type is not None and not isinstance(self.mime_type, str):
+            raise ValueError("Part.mime_type must be a string")
+
+        if self.type == "text":
+            if not isinstance(self.text, str):
+                raise ValueError("text Part requires text")
+            if self.source is not None:
+                raise ValueError("text Part cannot have source")
+            if self.embedding is not None:
+                raise ValueError("text Part cannot have embedding")
+            return
+
+        if self.type == "embedding":
+            if not isinstance(self.embedding, list) or not all(
+                isinstance(x, (int, float)) for x in self.embedding
+            ):
+                raise ValueError("embedding Part requires embedding: list[number]")
+            if self.source is not None:
+                raise ValueError("embedding Part cannot have source")
+            if self.text is not None:
+                raise ValueError("embedding Part cannot have text")
+            return
+
+        if self.type in {"image", "audio", "video", "file"}:
+            if self.source is None:
+                raise ValueError(f"{self.type} Part requires source")
+            if not isinstance(
+                self.source,
+                (PartSourceBytes, PartSourcePath, PartSourceUrl, PartSourceRef),
+            ):
+                raise ValueError("Part.source must be a PartSource object")
+            if self.text is not None:
+                raise ValueError(f"{self.type} Part cannot have text")
+            if self.embedding is not None:
+                raise ValueError(f"{self.type} Part cannot have embedding")
+            if self.mime_type and self.type in {"image", "audio", "video"}:
+                prefix = f"{self.type}/"
+                if not self.mime_type.startswith(prefix):
+                    raise ValueError(
+                        f"{self.type} Part mime_type must start with {prefix!r}"
+                    )
+            return
+
+        if self.type in {"tool_call", "tool_result"}:
+            if self.source is not None:
+                raise ValueError(f"{self.type} Part cannot have source")
+            if self.text is not None:
+                raise ValueError(f"{self.type} Part cannot have text")
+            if self.embedding is not None:
+                raise ValueError(f"{self.type} Part cannot have embedding")
+            return
+
+        raise ValueError(f"unknown Part.type: {self.type}")
+
+    @staticmethod
+    def from_text(text: str) -> "Part":
+        return Part(type="text", text=text)
+
+    @staticmethod
+    def tool_call(
+        *, name: str, arguments: Any, tool_call_id: str | None = None
+    ) -> "Part":
+        meta: dict[str, Any] = {"name": name, "arguments": arguments}
+        if tool_call_id is not None:
+            meta["tool_call_id"] = tool_call_id
+        return Part(type="tool_call", meta=meta)
+
+    @staticmethod
+    def tool_result(
+        *,
+        name: str,
+        result: Any,
+        tool_call_id: str | None = None,
+        is_error: bool | None = None,
+    ) -> "Part":
+        meta: dict[str, Any] = {"name": name, "result": result}
+        if tool_call_id is not None:
+            meta["tool_call_id"] = tool_call_id
+        if is_error is not None:
+            meta["is_error"] = bool(is_error)
+        return Part(type="tool_result", meta=meta)
+
+    @staticmethod
+    def embedding_part(vector: list[float]) -> "Part":
+        return Part(type="embedding", embedding=vector)
+
+    def require_text(self) -> str:
+        if self.type != "text" or self.text is None:
+            raise invalid_request_error("Part is not text")
+        return self.text
+
+    def require_source(self) -> PartSource:
+        if self.source is None:
+            raise invalid_request_error("Part has no source")
+        return self.source
+
+
+@dataclass(frozen=True, slots=True)
+class Message:
+    role: Role
+    content: list[Part]
+
+
+@dataclass(frozen=True, slots=True)
+class OutputTextSpec:
+    format: Literal["text", "json"] = "text"
+    json_schema: Any | None = None
+    max_output_tokens: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class OutputImageSpec:
+    n: int | None = None
+    size: str | None = None
+    format: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class OutputAudioSpec:
+    voice: str | None = None
+    format: str | None = None
+    language: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class OutputVideoSpec:
+    duration_sec: int | None = None
+    aspect_ratio: str | None = None
+    fps: int | None = None
+    format: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class OutputEmbeddingSpec:
+    dimensions: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Tool:
+    """
+    Minimal function tool declaration (provider-agnostic).
+
+    - `parameters` is a JSON Schema object describing the function arguments.
+    - Providers may support only a subset of JSON Schema/OpenAPI Schema.
+    """
+
+    name: str
+    description: str | None = None
+    parameters: dict[str, Any] | None = None
+    strict: bool | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ToolChoice:
+    mode: ToolChoiceMode = "auto"
+    name: str | None = None
+
+    def normalized(self) -> "ToolChoice":
+        mode = self.mode.strip().lower()
+        if mode not in {"none", "auto", "required", "tool"}:
+            raise invalid_request_error(f"unknown tool_choice.mode: {self.mode}")
+        name = self.name.strip() if isinstance(self.name, str) else None
+        if mode == "tool" and not name:
+            raise invalid_request_error("tool_choice.name required when mode='tool'")
+        if mode != "tool" and name is not None:
+            raise invalid_request_error(
+                "tool_choice.name only allowed when mode='tool'"
+            )
+        return ToolChoice(mode=cast(ToolChoiceMode, mode), name=name)
+
+
+@dataclass(frozen=True, slots=True)
+class OutputSpec:
+    modalities: list[Modality]
+    text: OutputTextSpec | None = None
+    image: OutputImageSpec | None = None
+    audio: OutputAudioSpec | None = None
+    video: OutputVideoSpec | None = None
+    embedding: OutputEmbeddingSpec | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class GenerateParams:
+    temperature: float | None = None
+    top_p: float | None = None
+    seed: int | None = None
+    max_output_tokens: int | None = None
+    stop: list[str] | None = None
+    timeout_ms: int | None = None
+    idempotency_key: str | None = None
+    reasoning: ReasoningSpec | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class GenerateRequest:
+    model: str = field(
+        metadata={
+            "description": 'Model string in the form "{provider}:{model_id}" (e.g. "openai:gpt-4o-mini")',
+            "pattern": r"^[^\s:]+:[^\s]+$",
+            "examples": ["openai:gpt-4o-mini"],
+        }
+    )
+    input: list[Message]
+    output: OutputSpec
+    params: GenerateParams = field(default_factory=GenerateParams)
+    wait: bool = True
+    tools: list[Tool] | None = None
+    tool_choice: ToolChoice | None = None
+    provider_options: dict[str, Any] = field(default_factory=dict)
+
+    def provider(self) -> str:
+        if ":" not in self.model:
+            raise invalid_request_error('model must be "{provider}:{model_id}"')
+        return self.model.split(":", 1)[0]
+
+    def model_id(self) -> str:
+        if ":" not in self.model:
+            raise invalid_request_error('model must be "{provider}:{model_id}"')
+        return self.model.split(":", 1)[1]
+
+
+@dataclass(frozen=True, slots=True)
+class Usage:
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+    total_tokens: int | None = None
+    seconds: float | None = None
+    image_count: int | None = None
+    video_seconds: float | None = None
+    cost_estimate: float | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class JobInfo:
+    job_id: str
+    poll_after_ms: int = 1_000
+    expires_at: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class GenerateResponse:
+    id: str
+    provider: str
+    model: str
+    status: Status
+    output: list[Message] = field(default_factory=list)
+    usage: Usage | None = None
+    job: JobInfo | None = None
+    error: ErrorInfo | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class GenerateEvent:
+    type: str
+    data: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class Capability:
+    input_modalities: set[Modality]
+    output_modalities: set[Modality]
+    supports_stream: bool
+    supports_job: bool
+    supports_tools: bool = False
+    supports_json_schema: bool = False
+
+
+def detect_mime_type(path: str) -> str | None:
+    suffix = Path(path).suffix.lower()
+    if suffix in {".png"}:
+        return "image/png"
+    if suffix in {".jpg", ".jpeg"}:
+        return "image/jpeg"
+    if suffix in {".webp"}:
+        return "image/webp"
+    if suffix in {".wav"}:
+        return "audio/wav"
+    if suffix in {".mp3"}:
+        return "audio/mpeg"
+    if suffix in {".m4a"}:
+        return "audio/mp4"
+    if suffix in {".mp4"}:
+        return "video/mp4"
+    if suffix in {".mov"}:
+        return "video/quicktime"
+    return None
+
+
+def file_to_bytes(path: str, max_bytes: int) -> bytes:
+    st = os.stat(path)
+    if st.st_size > max_bytes:
+        raise not_supported_error(
+            f"file too large for inline bytes ({st.st_size} > {max_bytes}); use url/ref instead"
+        )
+    with open(path, "rb") as f:
+        return f.read()
+
+
+def bytes_to_base64(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii")
+
+
+def sniff_image_mime_type(data: bytes) -> str | None:
+    if len(data) >= 8 and data.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "image/png"
+    if len(data) >= 3 and data.startswith(b"\xff\xd8\xff"):
+        return "image/jpeg"
+    if len(data) >= 12 and data.startswith(b"RIFF") and data[8:12] == b"WEBP":
+        return "image/webp"
+    if len(data) >= 6 and data[:6] in {b"GIF87a", b"GIF89a"}:
+        return "image/gif"
+    return None

nous/py.typed

@@ -0,0 +1 @@
+

nous_genai-0.1.0.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: nous-genai
+Version: 0.1.0
+Summary: Single-endpoint GenAI SDK (multi-provider, multimodal)
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/gravtice/nous-genai
+Project-URL: Issues, https://github.com/gravtice/nous-genai/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.25.0
+Requires-Dist: uvicorn>=0.30.0
+Dynamic: license-file
+
+# nous-genai
+
+![CI](https://github.com/gravtice/nous-genai/actions/workflows/ci.yml/badge.svg)
+![Python](https://img.shields.io/badge/python-≥3.12-blue)
+![License](https://img.shields.io/badge/license-Apache--2.0-green)
+
+中文文档：`readme_zh.md`
+
+One interface for calling multimodal models; four ways to use: Skill, MCP, CLI, SDK.
+
+## Features
+
+- **Multi-provider**: OpenAI, Google (Gemini), Anthropic (Claude), Aliyun (DashScope/Bailian), Volcengine (Doubao/Ark), Tuzi
+- **Multimodal**: text/image/audio/video input and output (model-dependent)
+- **Unified API**: a single `Client.generate()` for all providers
+- **Streaming**: `generate_stream()` for incremental output
+- **Tool calling**: function tools (model/provider-dependent)
+- **JSON Schema output**: structured output (model/provider-dependent)
+- **MCP Server**: Streamable HTTP and SSE transport
+- **Security**: SSRF protection, DNS pinning, download limits, Bearer token auth (MCP)
+
+## Installation
+
+```bash
+pip install nous-genai
+```
+
+For development:
+
+```bash
+pip install -e .
+# or (recommended)
+uv sync
+```
+
+## Configuration (Zero-parameter)
+
+SDK/CLI/MCP loads env files automatically with priority (high → low):
+
+`.env.local > .env.production > .env.development > .env.test`
+
+Process env vars override `.env.*` (the loader uses `os.environ.setdefault()`).
+
+Minimal `.env.local` (OpenAI only):
+
+```bash
+NOUS_GENAI_OPENAI_API_KEY=...
+NOUS_GENAI_TIMEOUT_MS=120000
+```
+
+See `docs/CONFIGURATION.md` or copy `.env.example` to `.env.local`.
+
+## Quickstart
+
+### Text generation
+
+```python
+from nous.genai import Client, GenerateRequest, Message, OutputSpec, Part
+
+client = Client()
+resp = client.generate(
+    GenerateRequest(
+        model="openai:gpt-4o-mini",
+        input=[Message(role="user", content=[Part.from_text("Hello!")])],
+        output=OutputSpec(modalities=["text"]),
+    )
+)
+print(resp.output[0].content[0].text)
+```
+
+### Streaming
+
+```python
+import sys
+from nous.genai import Client, GenerateRequest, Message, OutputSpec, Part
+
+client = Client()
+req = GenerateRequest(
+    model="openai:gpt-4o-mini",
+    input=[Message(role="user", content=[Part.from_text("Tell me a joke")])],
+    output=OutputSpec(modalities=["text"]),
+)
+for ev in client.generate_stream(req):
+    if ev.type == "output.text.delta":
+        sys.stdout.write(str(ev.data.get("delta", "")))
+        sys.stdout.flush()
+print()
+```
+
+### Image understanding
+
+```python
+from nous.genai import Client, GenerateRequest, Message, OutputSpec, Part, PartSourcePath
+from nous.genai.types import detect_mime_type
+
+path = "./cat.png"
+mime = detect_mime_type(path) or "application/octet-stream"
+
+client = Client()
+resp = client.generate(
+    GenerateRequest(
+        model="openai:gpt-4o-mini",
+        input=[
+            Message(
+                role="user",
+                content=[
+                    Part.from_text("Describe this image"),
+                    Part(type="image", mime_type=mime, source=PartSourcePath(path=path)),
+                ],
+            )
+        ],
+        output=OutputSpec(modalities=["text"]),
+    )
+)
+print(resp.output[0].content[0].text)
+```
+
+### List available models
+
+```python
+from nous.genai import Client
+
+client = Client()
+print(client.list_all_available_models())
+```
+
+## Providers
+
+| Provider | Notes |
+|----------|------|
+| `openai` | GPT-4, DALL·E, Whisper, TTS |
+| `google` | Gemini, Imagen, Veo |
+| `anthropic` | Claude |
+| `aliyun` | DashScope / Bailian (OpenAI-compatible + AIGC) |
+| `volcengine` | Ark / Doubao (OpenAI-compatible) |
+| `tuzi-web` / `tuzi-openai` / `tuzi-google` / `tuzi-anthropic` | Tuzi adapters |
+
+## Binary output
+
+Binary `Part.source` is a tagged union:
+
+- **Input**: `bytes/path/base64/url/ref` (MCP forbids `bytes/path`)
+- **Output**: `url/base64/ref` (SDK does not auto-download to disk)
+
+If you need to write to file, see `examples/demo.py` (`_write_binary()`), or reuse `Client.download_to_file()` for the built-in safe downloader.
+
+## CLI & MCP Server
+
+```bash
+# CLI
+uv run genai --model openai:gpt-4o-mini --prompt "Hello"
+uv run genai model available --all
+
+# MCP Server
+uv run genai-mcp-server                    # Streamable HTTP: /mcp, SSE: /sse
+uv run genai-mcp-cli tools                 # Debug CLI
+```
+
+## Security
+
+- **SSRF protection**: rejects private/loopback URLs by default (`NOUS_GENAI_ALLOW_PRIVATE_URLS=1` to allow)
+- **DNS pinning**: mitigates DNS rebinding
+- **Download limit**: 128MiB per URL by default (`NOUS_GENAI_URL_DOWNLOAD_MAX_BYTES`)
+- **Bearer token auth**: for MCP server
+- **Token rules**: fine-grained access control
+
+## Testing
+
+```bash
+uv run pytest tests/ -v
+```
+
+## Docs
+
+- [Configuration](docs/CONFIGURATION.md)
+- [Architecture](docs/ARCHITECTURE_DESIGN.md)
+- [MCP Server Security Review](docs/MCP_SERVER_CLI_SECURITY_REVIEW.md)
+- [Contributing](CONTRIBUTING.md)
+- [Changelog](CHANGELOG.md)
+
+## License
+
+[Apache-2.0](LICENSE)

nous_genai-0.1.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+nous/__init__.py,sha256=Hh6QnLL0rRIVOTu33-Yt8GxHSNGfckYHTIsNP5prvEE,32
+nous/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+nous/genai/__init__.py,sha256=VY43n2cxXUP8ozW5vkW3P_WyEkGWYQY17NVHJHdRY24,1037
+nous/genai/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+nous/genai/cli.py,sha256=f_e1Ss1ehVw-lfVaF9wEuquP5e0Fib2FfSnr0zmnTrQ,42733
+nous/genai/client.py,sha256=uKwttxMSkXCa1w8i7g3Mqs0L6ZCZZvMk7HdTXPfzoV0,26249
+nous/genai/mcp_cli.py,sha256=bhAhL4r9x3Xkzb_7NypfUELAHqdIiC23LQbSAGZIPAE,10356
+nous/genai/mcp_server.py,sha256=1NlJnAIV4LhMUDJ4BmH60KU7Jrx-bfivgIbcIaofPVU,40507
+nous/genai/types.py,sha256=g589VUakFeMEIN3-AwHHKP6PCcMDlD6svKZcrBeu0Ts,13011
+nous/genai/_internal/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+nous/genai/_internal/capability_rules.py,sha256=uCYeBDbJZx-S4Bib66oi_v3nZXS7dG84X0eEDifMjbY,13299
+nous/genai/_internal/config.py,sha256=JfT8uhU_QSNfPEKPU614pB_jRJbMBnVkbHnOm7UeYoc,3243
+nous/genai/_internal/errors.py,sha256=JZ2GIdFjae1I9ar7BCXmy01VenTrgvn4WfhbFNVF4i4,1639
+nous/genai/_internal/http.py,sha256=XcO13YOs28N-Tq8WKi0a4REIHgWQxXBgzPxDM_MBSo0,30236
+nous/genai/_internal/json_schema.py,sha256=y2978JFfUS-COLgemff7qyCmbTqLV-Tg_LhhLwB4QTU,1591
+nous/genai/providers/__init__.py,sha256=MDbuoAPxnULdSH-jg7L7rjjQlDM-DL8bFK4615wZQEY,360
+nous/genai/providers/aliyun.py,sha256=FOAhQOlHmJC3Nm5cagPbf6JQ94XtM-TKFVCH51PPSLM,18977
+nous/genai/providers/anthropic.py,sha256=MShEm1lAw3dpbCPcsRz9eqWHt_x20EBswe4cJ4-ZgHo,17920
+nous/genai/providers/gemini.py,sha256=Kb-oe7zVYlm--EGla1yZ0BavUx11GkAO1d0dtyLSC3A,58320
+nous/genai/providers/openai.py,sha256=HxhR3pABZMLPtECAq4rUwuDSsBM4bb7AF66AVYLjUIU,75303
+nous/genai/providers/tuzi.py,sha256=arkU5UBtcwb4bNOEEMcNW9hww8NNzXxc1-d7TAv_2Hg,44761
+nous/genai/providers/volcengine.py,sha256=hZVO9jIBLqKSqwZsysOoO_FtrLGGUvJVbfLDKzXITQc,9962
+nous/genai/reference/__init__.py,sha256=nfMsgNMUF1CHw3qslPA5Zniy8rBds9eISBpkCshbbJE,409
+nous/genai/reference/catalog.py,sha256=FeF3iabPNgNdWFR40ffAYTPHXfuEY4zT8G9asrlBD14,6633
+nous/genai/reference/mappings.py,sha256=SH0u1vYiwAKvuCzdAX6D5LSbL3JMjotu8IE63BBqmv8,14384
+nous/genai/reference/mode_overrides.py,sha256=xNzbzWwe9Z0WW2J6DO3rKDmcsy2Y3vNJ5PQHAbK40kU,760
+nous/genai/reference/model_catalog.py,sha256=87wGuPF-pNmMiJ3ZzrJup98VTZSsBJTgheg2hU3-lIg,2240
+nous/genai/reference/model_catalog_data/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+nous/genai/reference/model_catalog_data/aliyun.py,sha256=z8UwxdgUnpFUWRwrICwM_qLJCOWFgd7gXrlNBhxUiGw,2455
+nous/genai/reference/model_catalog_data/anthropic.py,sha256=nG3el5OkDVeCFXaRHLj1VsGIRhjvvNGoNUolyLz3ZJc,198
+nous/genai/reference/model_catalog_data/google.py,sha256=7LefJB9W7N0DvQIUZmAE4w3IEIlbSE0hkzhYRD1SpFc,1267
+nous/genai/reference/model_catalog_data/openai.py,sha256=siwx-htP7kPtlcDPzl6ommol3Jpg6zwZfta3_MSgaUI,846
+nous/genai/reference/model_catalog_data/tuzi_anthropic.py,sha256=8jLckkoU0zwjoaTsAcdK03yY0u6iikK9p32HnL55mOk,519
+nous/genai/reference/model_catalog_data/tuzi_google.py,sha256=3S4mJfN1VtsNkTxbb42AeKc-oF84KRPTILA39QOpCew,540
+nous/genai/reference/model_catalog_data/tuzi_openai.py,sha256=K_w802dimRfQmmlgc4P2eI6ohvqAsQt2GoWb0K57BX0,1632
+nous/genai/reference/model_catalog_data/tuzi_web.py,sha256=wKYo9yndsi5yQA44HB2omQKz6esHvOqZKjMizOvFdbc,3081
+nous/genai/reference/model_catalog_data/volcengine.py,sha256=GxDELF9z8sbYyOEu-SpYluCal0tTAfFFLkS9-vXt1hg,3657
+nous/genai/tools/__init__.py,sha256=YWNhBKZ4t6diXI5SlCHA5OAIhLLOOA3vwQ6jClJsO2o,292
+nous/genai/tools/output_parser.py,sha256=epHW-fLBatrjMTl2nMvh_vFWFEmP8Xj2pZ5fosaZxTc,3968
+nous_genai-0.1.0.dist-info/licenses/LICENSE,sha256=yMLznCFyvxXAx7UUyAtq1gYFyzRsqGngYiaRF9R33Lg,10757
+nous_genai-0.1.0.dist-info/METADATA,sha256=UmxjLMmPE1GA4FpMFbo2HrjdThAB_BDMg4fMnhr1AT4,5474
+nous_genai-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nous_genai-0.1.0.dist-info/entry_points.txt,sha256=j_cgAhxjPu7wtlo_zcdFLmz58dSxvnmSFM4f0A-ozEc,132
+nous_genai-0.1.0.dist-info/top_level.txt,sha256=yUcst4OAspsyKhX0y5ENzFkJKzR_gislA5MykV1pVbk,5
+nous_genai-0.1.0.dist-info/RECORD,,

nous_genai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nous_genai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+genai = nous.genai.cli:main
+genai-mcp-cli = nous.genai.mcp_cli:main
+genai-mcp-server = nous.genai.mcp_server:main