llm-deepseek-ya 1.0.0__tar.gz

llm_deepseek_ya-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 delijati
+
+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_deepseek_ya-1.0.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: llm-deepseek-ya
+Version: 1.0.0
+Summary: Yet another LLM access to DeepSeek's API
+Author: Josip Delic
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/delijati/llm-deepseek-ya
+Project-URL: Issues, https://github.com/delijati/llm-deepseek-ya/issues
+Project-URL: CI, https://github.com/delijati/llm-deepseek-ya/actions
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: llm
+Requires-Dist: httpx
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-httpx; extra == "test"
+Requires-Dist: pytest-recording; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# llm-deepseek-ya
+
+[![PyPI](https://img.shields.io/pypi/v/llm-deepseek-ya.svg)](https://pypi.org/project/llm-deepseek-ya/0.1.0/)
+[![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/delijati/llm-deepseek-ya?include_prereleases)](https://github.com/delijati/llm-deepseek-ya/releases)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/delijati/llm-deepseek-ya/blob/main/LICENSE)
+
+LLM access to DeepSeek's API
+
+## Installation
+
+Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
+
+```bash
+llm install llm-deepseek-ya
+```
+
+## Usage
+
+First, set an [API key](https://platform.deepseek.com/api_keys) for DeepSeek:
+
+```bash
+llm keys set deepseek
+# Paste key here
+```
+
+Run `llm models` to list the models, and `llm models --options` to include a list of their options.
+
+### Running Prompts
+
+Run prompts like this:
+
+```bash
+llm -m deepseek-chat "Describe a futuristic city on Mars"
+llm -m deepseek-chat-completion "The AI began to dream, and in its dreams," -o echo true
+llm -m deepseek-reasoner "Write a Python function to sort a list of numbers"
+```
+
+Note: The DeepSeek Reasoner model only supports the chat endpoint, not the completion endpoint.
+
+### DeepSeek Reasoner Model
+
+The DeepSeek Reasoner model uses a Chain of Thought (CoT) approach to solve complex problems, showing its reasoning process before providing the final answer.
+
+The plugin shows the model's chain of thought reasoning by default in non-streaming mode. The reasoning feature is currently only supported in non-streaming mode.
+
+```bash
+# Normal usage - will show reasoning by default
+llm -m deepseek-reasoner "What is 537 * 943?"
+
+# Hide reasoning when you only want the final answer
+llm -m deepseek-reasoner "What is 537 * 943?" -o show_reasoning false
+```
+
+### Features
+
+#### Prefill
+
+The `prefill` option allows you to provide initial text for the model's response. This is useful for guiding the model's output.
+
+Example:
+
+```bash
+llm -m deepseek-chat "What are some wild and crazy activities for a holiday party?" -o prefill "Here are some off-the-wall ideas to make your holiday party unforgettable [warning: these may not be suitable for work holiday parties]:"
+```
+
+You can also load prefill text from a file:
+
+```bash
+# Create a file with your prefill text
+echo "Here are some unique holiday party ideas:" > prefill.txt
+
+# Use the file path as the prefill value
+llm -m deepseek-chat "What are some fun activities for a holiday party?" -o prefill prefill.txt
+```
+
+This is especially useful for longer prefill text that would be unwieldy on the command line.
+
+#### JSON Response Format
+
+The `response_format` option allows you to specify that the model should output its response in JSON format. To ensure the model outputs valid JSON, include the word "json" in the system or user prompt. Optionally, you can provide an example of the desired JSON format to guide the model.
+
+Example:
+
+```bash
+llm -m deepseek-chat "What are some fun activities for a holiday party?" -o response_format json_object --system "json"
+```
+
+To guide the model further, you can provide an example JSON structure:
+
+```bash
+llm -m deepseek-chat "What are some way to tell if a holiday party is fun?" -o response_format json_object --system 'EXAMPLE JSON OUTPUT: {"event": "holiday_party_fun", "success_metric": ["..."]}'
+```
+
+#### JSON Schema Support
+
+DeepSeek Chat models support JSON schema output (via LLM's `--schema` option). When you provide a schema, the plugin automatically enables JSON mode and includes the schema in the system message to guide the model's output.
+
+**Important Note:** DeepSeek's API does not validate the output against the schema - it only uses JSON mode. The schema is provided to the model as guidance, so the model will attempt to follow it, but strict validation is not enforced.
+
+Example:
+
+```bash
+llm -m deepseek-chat "Generate a user profile" --schema '{"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "number"}, "email": {"type": "string"}}, "required": ["name", "age"]}'
+```
+
+You can also use LLM's schema file support:
+
+```bash
+# Create a schema file
+cat > user_schema.json << 'EOF'
+{
+  "type": "object",
+  "properties": {
+    "name": {"type": "string"},
+    "age": {"type": "number"},
+    "email": {"type": "string"},
+    "interests": {"type": "array", "items": {"type": "string"}}
+  },
+  "required": ["name", "age"]
+}
+EOF
+
+# Use the schema file
+llm -m deepseek-chat "Generate a user profile for a software developer" --schema user_schema.json
+```
+
+## Development
+
+To set up this plugin locally, first checkout the code. Then create a new virtual environment:
+
+```bash
+cd llm-deepseek-ya
+python3 -m venv venv
+source venv/bin/activate
+```

llm_deepseek_ya-1.0.0/README.md

@@ -0,0 +1,135 @@
+# llm-deepseek-ya
+
+[![PyPI](https://img.shields.io/pypi/v/llm-deepseek-ya.svg)](https://pypi.org/project/llm-deepseek-ya/0.1.0/)
+[![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/delijati/llm-deepseek-ya?include_prereleases)](https://github.com/delijati/llm-deepseek-ya/releases)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/delijati/llm-deepseek-ya/blob/main/LICENSE)
+
+LLM access to DeepSeek's API
+
+## Installation
+
+Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
+
+```bash
+llm install llm-deepseek-ya
+```
+
+## Usage
+
+First, set an [API key](https://platform.deepseek.com/api_keys) for DeepSeek:
+
+```bash
+llm keys set deepseek
+# Paste key here
+```
+
+Run `llm models` to list the models, and `llm models --options` to include a list of their options.
+
+### Running Prompts
+
+Run prompts like this:
+
+```bash
+llm -m deepseek-chat "Describe a futuristic city on Mars"
+llm -m deepseek-chat-completion "The AI began to dream, and in its dreams," -o echo true
+llm -m deepseek-reasoner "Write a Python function to sort a list of numbers"
+```
+
+Note: The DeepSeek Reasoner model only supports the chat endpoint, not the completion endpoint.
+
+### DeepSeek Reasoner Model
+
+The DeepSeek Reasoner model uses a Chain of Thought (CoT) approach to solve complex problems, showing its reasoning process before providing the final answer.
+
+The plugin shows the model's chain of thought reasoning by default in non-streaming mode. The reasoning feature is currently only supported in non-streaming mode.
+
+```bash
+# Normal usage - will show reasoning by default
+llm -m deepseek-reasoner "What is 537 * 943?"
+
+# Hide reasoning when you only want the final answer
+llm -m deepseek-reasoner "What is 537 * 943?" -o show_reasoning false
+```
+
+### Features
+
+#### Prefill
+
+The `prefill` option allows you to provide initial text for the model's response. This is useful for guiding the model's output.
+
+Example:
+
+```bash
+llm -m deepseek-chat "What are some wild and crazy activities for a holiday party?" -o prefill "Here are some off-the-wall ideas to make your holiday party unforgettable [warning: these may not be suitable for work holiday parties]:"
+```
+
+You can also load prefill text from a file:
+
+```bash
+# Create a file with your prefill text
+echo "Here are some unique holiday party ideas:" > prefill.txt
+
+# Use the file path as the prefill value
+llm -m deepseek-chat "What are some fun activities for a holiday party?" -o prefill prefill.txt
+```
+
+This is especially useful for longer prefill text that would be unwieldy on the command line.
+
+#### JSON Response Format
+
+The `response_format` option allows you to specify that the model should output its response in JSON format. To ensure the model outputs valid JSON, include the word "json" in the system or user prompt. Optionally, you can provide an example of the desired JSON format to guide the model.
+
+Example:
+
+```bash
+llm -m deepseek-chat "What are some fun activities for a holiday party?" -o response_format json_object --system "json"
+```
+
+To guide the model further, you can provide an example JSON structure:
+
+```bash
+llm -m deepseek-chat "What are some way to tell if a holiday party is fun?" -o response_format json_object --system 'EXAMPLE JSON OUTPUT: {"event": "holiday_party_fun", "success_metric": ["..."]}'
+```
+
+#### JSON Schema Support
+
+DeepSeek Chat models support JSON schema output (via LLM's `--schema` option). When you provide a schema, the plugin automatically enables JSON mode and includes the schema in the system message to guide the model's output.
+
+**Important Note:** DeepSeek's API does not validate the output against the schema - it only uses JSON mode. The schema is provided to the model as guidance, so the model will attempt to follow it, but strict validation is not enforced.
+
+Example:
+
+```bash
+llm -m deepseek-chat "Generate a user profile" --schema '{"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "number"}, "email": {"type": "string"}}, "required": ["name", "age"]}'
+```
+
+You can also use LLM's schema file support:
+
+```bash
+# Create a schema file
+cat > user_schema.json << 'EOF'
+{
+  "type": "object",
+  "properties": {
+    "name": {"type": "string"},
+    "age": {"type": "number"},
+    "email": {"type": "string"},
+    "interests": {"type": "array", "items": {"type": "string"}}
+  },
+  "required": ["name", "age"]
+}
+EOF
+
+# Use the schema file
+llm -m deepseek-chat "Generate a user profile for a software developer" --schema user_schema.json
+```
+
+## Development
+
+To set up this plugin locally, first checkout the code. Then create a new virtual environment:
+
+```bash
+cd llm-deepseek-ya
+python3 -m venv venv
+source venv/bin/activate
+```

llm_deepseek_ya-1.0.0/llm_deepseek.py

@@ -0,0 +1,248 @@
+import llm
+from llm.default_plugins.openai_models import Chat
+from pathlib import Path
+import json
+import time
+import httpx
+import os
+from typing import Optional
+from pydantic import Field
+
+# Constants for cache timeout and API base URL
+CACHE_TIMEOUT = 3600
+DEEPSEEK_API_BASE = "https://api.deepseek.com/beta"  # For inference
+DEEPSEEK_MODELS_URL = "https://api.deepseek.com/models"  # For listing models
+
+
+def get_deepseek_models():
+    """Fetch and cache DeepSeek models."""
+    key = llm.get_key("", "deepseek", "LLM_DEEPSEEK_KEY")
+    headers = {"Authorization": f"Bearer {key}"} if key else None
+    ret = fetch_cached_json(
+        url=DEEPSEEK_MODELS_URL,
+        path=llm.user_dir() / "deepseek_models.json",
+        cache_timeout=CACHE_TIMEOUT,
+        headers=headers,
+    )["data"]
+    return ret
+
+
+def get_model_ids_with_aliases(models):
+    """Extract model IDs and create empty aliases list."""
+    return [(model["id"], []) for model in models]
+
+
+class DeepSeekChat(Chat):
+    needs_key = "deepseek"
+    key_env_var = "LLM_DEEPSEEK_KEY"
+
+    def __init__(self, model_id, **kwargs):
+        kwargs.setdefault("supports_schema", True)
+        super().__init__(model_id, **kwargs)
+        self.api_base = DEEPSEEK_API_BASE
+
+    def __str__(self):
+        return f"DeepSeek Chat: {self.model_id}"
+
+    class Options(Chat.Options):
+        prefill: Optional[str] = Field(
+            description="Initial text for the model's response (beta feature). Uses DeepSeek's Chat Prefix Completion.",
+            default=None,
+        )
+        response_format: Optional[str] = Field(
+            description="Format of the response (e.g., 'json_object').", default=None
+        )
+        show_reasoning: Optional[bool] = Field(
+            description="Show the chain of thought reasoning for the DeepSeek Reasoner model.",
+            default=True,
+        )
+
+    def execute(self, prompt, stream, response, conversation, key=None):
+        messages = self._build_messages(conversation, prompt)
+        response._prompt_json = {"messages": messages}
+        kwargs = self.build_kwargs(prompt, stream)
+
+        max_tokens = kwargs.pop("max_tokens", 8192)
+
+        # Enable JSON mode if schema is provided or response_format is set
+        if prompt.schema or prompt.options.response_format:
+            kwargs["response_format"] = {"type": "json_object"}
+
+            # If schema is provided, add it to the system message as guidance
+            # Note: DeepSeek doesn't validate against the schema, but the model can follow it
+            if prompt.schema:
+                schema_instruction = f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(prompt.schema, indent=2)}"
+                # Add schema to system message or create one if it doesn't exist
+                if messages and messages[0].get("role") == "system":
+                    messages[0]["content"] += schema_instruction
+                else:
+                    messages.insert(
+                        0,
+                        {
+                            "role": "system",
+                            "content": f"You are a helpful assistant.{schema_instruction}",
+                        },
+                    )
+
+        # Remove options that aren't supported by the OpenAI client
+        kwargs.pop("prefill", None)
+        kwargs.pop("show_reasoning", None)
+        show_reasoning = prompt.options.show_reasoning
+
+        client = self.get_client(key)
+
+        try:
+            completion = client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                stream=stream,
+                max_tokens=max_tokens,
+                **kwargs,
+            )
+
+            if stream:
+                for chunk in completion:
+                    # Stream both reasoning content and regular content directly
+                    content = chunk.choices[0].delta.content
+                    reasoning_content = getattr(
+                        chunk.choices[0].delta, "reasoning_content", None
+                    )
+
+                    if reasoning_content is not None and show_reasoning:
+                        yield reasoning_content
+
+                    if content is not None:
+                        yield content
+            else:
+                # For non-streaming response
+                content = completion.choices[0].message.content
+                # If we have reasoning content and want to show it
+                if show_reasoning and hasattr(
+                    completion.choices[0].message, "reasoning_content"
+                ):
+                    reasoning = completion.choices[0].message.reasoning_content
+                    if reasoning:
+                        yield reasoning
+                        yield "\n\n"
+                # Then output the regular content
+                yield content
+
+            response.response_json = {"content": "".join(response._chunks)}
+
+            # Store reasoning_content in response if available
+            if not stream and hasattr(
+                completion.choices[0].message, "reasoning_content"
+            ):
+                response.response_json["reasoning_content"] = completion.choices[
+                    0
+                ].message.reasoning_content
+
+        except httpx.HTTPError as e:
+            raise llm.ModelError(f"DeepSeek API error: {str(e)}")
+
+    def _build_messages(self, conversation, prompt):
+        """Build the messages list for the API call."""
+        messages = []
+        if conversation:
+            for prev_response in conversation.responses:
+                messages.append(
+                    {"role": "user", "content": prev_response.prompt.prompt}
+                )
+                messages.append({"role": "assistant", "content": prev_response.text()})
+
+        # Add system message if provided
+        if prompt.system:
+            messages.append({"role": "system", "content": prompt.system})
+
+        messages.append({"role": "user", "content": prompt.prompt})
+
+        if prompt.options.prefill:
+            prefill_content = prompt.options.prefill
+            # Check if prefill value is a file path
+            if os.path.exists(prefill_content) and os.path.isfile(prefill_content):
+                try:
+                    with open(prefill_content, "r") as file:
+                        prefill_content = file.read()
+                except Exception as e:
+                    print(
+                        f"Warning: Could not read prefill file '{prompt.options.prefill}': {e}"
+                    )
+
+            messages.append(
+                {"role": "assistant", "content": prefill_content, "prefix": True}
+            )
+
+        return messages
+
+
+class DownloadError(Exception):
+    pass
+
+
+def fetch_cached_json(url, path, cache_timeout, headers=None):
+    """Fetch JSON data from a URL and cache it."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if path.is_file() and time.time() - path.stat().st_mtime < cache_timeout:
+        with open(path, "r") as file:
+            return json.load(file)
+
+    try:
+        response = httpx.get(url, headers=headers, follow_redirects=True)
+        response.raise_for_status()
+        with open(path, "w") as file:
+            json.dump(response.json(), file)
+        return response.json()
+    except httpx.HTTPError:
+        if path.is_file():
+            with open(path, "r") as file:
+                return json.load(file)
+        else:
+            raise DownloadError(
+                f"Failed to download data and no cache is available at {path}"
+            )
+
+
+@llm.hookimpl
+def register_models(register):
+    key = llm.get_key("", "deepseek", "LLM_DEEPSEEK_KEY")
+    if not key:
+        return
+    try:
+        models = get_deepseek_models()
+        models_with_aliases = get_model_ids_with_aliases(models)
+
+        # Register all Chat models
+        for model_id, aliases in models_with_aliases:
+            register(
+                DeepSeekChat(
+                    model_id=f"deepseek/{model_id}",
+                    model_name=model_id,
+                ),
+                aliases=[model_id],
+            )
+    except DownloadError as e:
+        print(f"Error fetching DeepSeek models: {e}")
+
+
+@llm.hookimpl
+def register_commands(cli):
+    @cli.command()
+    def deepseek_models():
+        """List available DeepSeek models."""
+        key = llm.get_key("", "deepseek", "LLM_DEEPSEEK_KEY")
+        if not key:
+            print("DeepSeek API key not set. Use 'llm keys set deepseek' to set it.")
+            return
+        try:
+            models = get_deepseek_models()
+            models_with_aliases = get_model_ids_with_aliases(models)
+
+            # Display all Chat models
+            for model_id, aliases in models_with_aliases:
+                print(f"DeepSeek Chat: deepseek/{model_id}")
+                print(f"  Aliases: {model_id}")
+                print()
+        except DownloadError as e:
+            print(f"Error fetching DeepSeek models: {e}")

llm_deepseek_ya-1.0.0/llm_deepseek_ya.egg-info/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: llm-deepseek-ya
+Version: 1.0.0
+Summary: Yet another LLM access to DeepSeek's API
+Author: Josip Delic
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/delijati/llm-deepseek-ya
+Project-URL: Issues, https://github.com/delijati/llm-deepseek-ya/issues
+Project-URL: CI, https://github.com/delijati/llm-deepseek-ya/actions
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: llm
+Requires-Dist: httpx
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-httpx; extra == "test"
+Requires-Dist: pytest-recording; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# llm-deepseek-ya
+
+[![PyPI](https://img.shields.io/pypi/v/llm-deepseek-ya.svg)](https://pypi.org/project/llm-deepseek-ya/0.1.0/)
+[![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/delijati/llm-deepseek-ya?include_prereleases)](https://github.com/delijati/llm-deepseek-ya/releases)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/delijati/llm-deepseek-ya/blob/main/LICENSE)
+
+LLM access to DeepSeek's API
+
+## Installation
+
+Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
+
+```bash
+llm install llm-deepseek-ya
+```
+
+## Usage
+
+First, set an [API key](https://platform.deepseek.com/api_keys) for DeepSeek:
+
+```bash
+llm keys set deepseek
+# Paste key here
+```
+
+Run `llm models` to list the models, and `llm models --options` to include a list of their options.
+
+### Running Prompts
+
+Run prompts like this:
+
+```bash
+llm -m deepseek-chat "Describe a futuristic city on Mars"
+llm -m deepseek-chat-completion "The AI began to dream, and in its dreams," -o echo true
+llm -m deepseek-reasoner "Write a Python function to sort a list of numbers"
+```
+
+Note: The DeepSeek Reasoner model only supports the chat endpoint, not the completion endpoint.
+
+### DeepSeek Reasoner Model
+
+The DeepSeek Reasoner model uses a Chain of Thought (CoT) approach to solve complex problems, showing its reasoning process before providing the final answer.
+
+The plugin shows the model's chain of thought reasoning by default in non-streaming mode. The reasoning feature is currently only supported in non-streaming mode.
+
+```bash
+# Normal usage - will show reasoning by default
+llm -m deepseek-reasoner "What is 537 * 943?"
+
+# Hide reasoning when you only want the final answer
+llm -m deepseek-reasoner "What is 537 * 943?" -o show_reasoning false
+```
+
+### Features
+
+#### Prefill
+
+The `prefill` option allows you to provide initial text for the model's response. This is useful for guiding the model's output.
+
+Example:
+
+```bash
+llm -m deepseek-chat "What are some wild and crazy activities for a holiday party?" -o prefill "Here are some off-the-wall ideas to make your holiday party unforgettable [warning: these may not be suitable for work holiday parties]:"
+```
+
+You can also load prefill text from a file:
+
+```bash
+# Create a file with your prefill text
+echo "Here are some unique holiday party ideas:" > prefill.txt
+
+# Use the file path as the prefill value
+llm -m deepseek-chat "What are some fun activities for a holiday party?" -o prefill prefill.txt
+```
+
+This is especially useful for longer prefill text that would be unwieldy on the command line.
+
+#### JSON Response Format
+
+The `response_format` option allows you to specify that the model should output its response in JSON format. To ensure the model outputs valid JSON, include the word "json" in the system or user prompt. Optionally, you can provide an example of the desired JSON format to guide the model.
+
+Example:
+
+```bash
+llm -m deepseek-chat "What are some fun activities for a holiday party?" -o response_format json_object --system "json"
+```
+
+To guide the model further, you can provide an example JSON structure:
+
+```bash
+llm -m deepseek-chat "What are some way to tell if a holiday party is fun?" -o response_format json_object --system 'EXAMPLE JSON OUTPUT: {"event": "holiday_party_fun", "success_metric": ["..."]}'
+```
+
+#### JSON Schema Support
+
+DeepSeek Chat models support JSON schema output (via LLM's `--schema` option). When you provide a schema, the plugin automatically enables JSON mode and includes the schema in the system message to guide the model's output.
+
+**Important Note:** DeepSeek's API does not validate the output against the schema - it only uses JSON mode. The schema is provided to the model as guidance, so the model will attempt to follow it, but strict validation is not enforced.
+
+Example:
+
+```bash
+llm -m deepseek-chat "Generate a user profile" --schema '{"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "number"}, "email": {"type": "string"}}, "required": ["name", "age"]}'
+```
+
+You can also use LLM's schema file support:
+
+```bash
+# Create a schema file
+cat > user_schema.json << 'EOF'
+{
+  "type": "object",
+  "properties": {
+    "name": {"type": "string"},
+    "age": {"type": "number"},
+    "email": {"type": "string"},
+    "interests": {"type": "array", "items": {"type": "string"}}
+  },
+  "required": ["name", "age"]
+}
+EOF
+
+# Use the schema file
+llm -m deepseek-chat "Generate a user profile for a software developer" --schema user_schema.json
+```
+
+## Development
+
+To set up this plugin locally, first checkout the code. Then create a new virtual environment:
+
+```bash
+cd llm-deepseek-ya
+python3 -m venv venv
+source venv/bin/activate
+```

llm_deepseek_ya-1.0.0/llm_deepseek_ya.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+llm_deepseek.py
+pyproject.toml
+llm_deepseek_ya.egg-info/PKG-INFO
+llm_deepseek_ya.egg-info/SOURCES.txt
+llm_deepseek_ya.egg-info/dependency_links.txt
+llm_deepseek_ya.egg-info/entry_points.txt
+llm_deepseek_ya.egg-info/requires.txt
+llm_deepseek_ya.egg-info/top_level.txt
+tests/test_deepseek.py

llm_deepseek_ya-1.0.0/llm_deepseek_ya.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

llm_deepseek_ya-1.0.0/llm_deepseek_ya.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[llm]
+deepseek = llm_deepseek

llm_deepseek_ya-1.0.0/llm_deepseek_ya.egg-info/requires.txt

@@ -0,0 +1,10 @@
+llm
+httpx
+
+[dev]
+ruff
+
+[test]
+pytest
+pytest-httpx
+pytest-recording

llm_deepseek_ya-1.0.0/llm_deepseek_ya.egg-info/top_level.txt

@@ -0,0 +1 @@
+llm_deepseek

llm_deepseek_ya-1.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "llm-deepseek-ya"
+version = "1.0.0"
+description = "Yet another LLM access to DeepSeek's API"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+dependencies = ["llm", "httpx"]
+authors = [{ name = "Josip Delic" }]
+
+[project.urls]
+Homepage = "https://github.com/delijati/llm-deepseek-ya"
+Issues = "https://github.com/delijati/llm-deepseek-ya/issues"
+CI = "https://github.com/delijati/llm-deepseek-ya/actions"
+
+[project.entry-points.llm]
+deepseek = "llm_deepseek"
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-httpx", "pytest-recording"]
+dev = ["ruff"]
+
+[tool.pytest.ini_options]
+filterwarnings = ["ignore::DeprecationWarning"]
+
+[tool.setuptools]
+py-modules = ["llm_deepseek"]
+
+[tool.ruff]
+# Same as flake8 max-line-length
+line-length = 88
+
+[tool.ruff.lint]
+# E501 - line too long (handled by formatter)
+# E203 - whitespace before ':' (conflicts with black)
+ignore = ["E501", "E203"]
+
+# Enable pycodestyle (E, W), pyflakes (F), and mccabe (C) rules
+select = ["E", "W", "F", "C90"]
+
+[tool.ruff.lint.mccabe]
+# Equivalent to flake8's max-complexity
+max-complexity = 15
+

llm_deepseek_ya-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

llm_deepseek_ya-1.0.0/tests/test_deepseek.py

@@ -0,0 +1,257 @@
+from click.testing import CliRunner
+import llm
+from llm.cli import cli
+import json
+import os
+import pytest
+import pydantic
+from pydantic import BaseModel
+from typing import List, Optional
+
+DEEPSEEK_API_KEY = os.environ.get("PYTEST_DEEPSEEK_API_KEY", None) or "sk-..."
+
+
+@pytest.mark.vcr
+def test_prompt():
+    """Test basic prompt with DeepSeek Chat model"""
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Name for a pet pelican, just the name", key=DEEPSEEK_API_KEY
+    )
+    text = str(response).strip()
+    # DeepSeek should return a response
+    assert len(text) > 0
+    # DeepSeek should return a response
+    assert "content" in response.response_json
+
+
+@pytest.mark.vcr
+def test_prompt_with_pydantic_schema():
+    """Test prompt with Pydantic schema - DeepSeek will use JSON mode"""
+
+    class Dog(pydantic.BaseModel):
+        name: str
+        age: int
+        bio: str
+
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Invent a cool dog", key=DEEPSEEK_API_KEY, schema=Dog, stream=False
+    )
+    result = json.loads(response.text())
+
+    # Verify the response has the required fields
+    assert "name" in result
+    assert "age" in result
+    assert "bio" in result
+    assert isinstance(result["name"], str)
+    assert isinstance(result["age"], int)
+    assert isinstance(result["bio"], str)
+
+
+@pytest.mark.vcr
+def test_prompt_with_multiple_dogs():
+    """Test prompt with nested Pydantic schema"""
+
+    class Dog(pydantic.BaseModel):
+        name: str
+        age: int
+        bio: str
+
+    class Dogs(BaseModel):
+        dogs: List[Dog]
+
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Invent 3 cool dogs", key=DEEPSEEK_API_KEY, schema=Dogs, stream=False
+    )
+    result = json.loads(response.text())
+
+    # Verify we got 3 dogs
+    assert "dogs" in result
+    assert len(result["dogs"]) == 3
+
+    # Verify each dog has the required fields
+    for dog in result["dogs"]:
+        assert "name" in dog
+        assert "age" in dog
+        assert "bio" in dog
+        assert isinstance(dog["name"], str)
+        assert isinstance(dog["age"], int)
+        assert isinstance(dog["bio"], str)
+
+
+@pytest.mark.vcr
+def test_json_response_format():
+    """Test the response_format option"""
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Return a JSON object with keys: name, color, and species for a parrot",
+        key=DEEPSEEK_API_KEY,
+        response_format="json_object",
+        stream=False,
+    )
+    result = json.loads(response.text())
+
+    # Should be valid JSON
+    assert isinstance(result, dict)
+
+
+@pytest.mark.vcr
+def test_reasoner_model():
+    """Test DeepSeek Reasoner model with reasoning output"""
+    model = llm.get_model("deepseek-reasoner")
+    response = model.prompt(
+        "What is 537 * 943?", key=DEEPSEEK_API_KEY, show_reasoning=True, stream=False
+    )
+    text = response.text()
+
+    # Should contain a numeric answer
+    assert "506" in text or "943" in text or "537" in text
+
+    # Check response_json contains reasoning_content if available
+    if response.response_json and "reasoning_content" in response.response_json:
+        assert isinstance(response.response_json["reasoning_content"], str)
+
+
+@pytest.mark.vcr
+def test_reasoner_model_hide_reasoning():
+    """Test DeepSeek Reasoner model with reasoning hidden"""
+    model = llm.get_model("deepseek-reasoner")
+    response = model.prompt(
+        "What is 2 + 2?", key=DEEPSEEK_API_KEY, show_reasoning=False, stream=False
+    )
+    text = response.text()
+
+    # Should contain the answer
+    assert "4" in text
+
+
+@pytest.mark.vcr
+def test_prefill_option():
+    """Test the prefill option for Chat Prefix Completion"""
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Continue this story",
+        key=DEEPSEEK_API_KEY,
+        prefill="Once upon a time",
+        stream=False,
+    )
+    text = response.text()
+
+    # Should have generated some text
+    assert len(text) > 0
+
+
+@pytest.mark.vcr
+def test_nested_model_direct_reference():
+    """Test nested Pydantic models with DeepSeek"""
+
+    class Address(BaseModel):
+        street: str
+        city: str
+
+    class Person(BaseModel):
+        name: str
+        address: Address
+
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Create a person named Alice living in San Francisco",
+        key=DEEPSEEK_API_KEY,
+        schema=Person,
+        stream=False,
+    )
+    result = json.loads(response.text())
+    assert "name" in result
+    assert "address" in result
+    assert "street" in result["address"]
+    assert "city" in result["address"]
+
+
+@pytest.mark.vcr
+def test_nested_model_optional():
+    """Test optional nested Pydantic models"""
+
+    class Company(BaseModel):
+        company_name: str
+
+    class Person(BaseModel):
+        name: str
+        employer: Optional[Company]
+
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Create a person named Bob who works at TechCorp",
+        key=DEEPSEEK_API_KEY,
+        schema=Person,
+        stream=False,
+    )
+    result = json.loads(response.text())
+    assert "name" in result
+    assert "employer" in result
+    if result["employer"] is not None:
+        assert "company_name" in result["employer"]
+
+
+@pytest.mark.vcr
+def test_nested_model_deep_composition():
+    """Test deeply nested Pydantic models"""
+
+    class Item(BaseModel):
+        product_name: str
+        quantity: int
+
+    class Order(BaseModel):
+        items: List[Item]
+
+    class Customer(BaseModel):
+        name: str
+        orders: List[Order]
+
+    model = llm.get_model("deepseek-chat")
+    response = model.prompt(
+        "Create a customer named Carol with 2 orders, each containing 2 items",
+        key=DEEPSEEK_API_KEY,
+        schema=Customer,
+        stream=False,
+    )
+    result = json.loads(response.text())
+    assert "name" in result
+    assert "orders" in result
+    assert len(result["orders"]) > 0
+    for order in result["orders"]:
+        assert "items" in order
+        assert len(order["items"]) > 0
+        for item in order["items"]:
+            assert "product_name" in item
+            assert "quantity" in item
+
+
+@pytest.mark.vcr
+def test_cli_deepseek_models(tmpdir, monkeypatch):
+    """Test the deepseek-models CLI command"""
+    user_dir = tmpdir / "llm.datasette.io"
+    user_dir.mkdir()
+    monkeypatch.setenv("LLM_USER_PATH", str(user_dir))
+
+    # With no key set should show error message
+    runner = CliRunner()
+    result = runner.invoke(cli, ["deepseek-models"])
+    assert result.exit_code == 0
+    assert "DeepSeek API key not set" in result.output or result.exit_code == 0
+
+    # Try with key set
+    monkeypatch.setenv("LLM_DEEPSEEK_KEY", DEEPSEEK_API_KEY)
+    result2 = runner.invoke(cli, ["deepseek-models"])
+    assert result2.exit_code == 0
+    # Should list some models
+    assert "deepseek" in result2.output.lower() or "DeepSeek" in result2.output
+
+
+@pytest.mark.vcr
+def test_supports_schema_attribute():
+    """Test that DeepSeek Chat models have supports_schema set to True"""
+    model = llm.get_model("deepseek-chat")
+    assert hasattr(model, "supports_schema")
+    assert model.supports_schema is True