everypixel-cli 0.2.2__tar.gz → 0.3.0__tar.gz

{everypixel_cli-0.2.2 → everypixel_cli-0.3.0}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.3.0] - 2026-09-18
+
+- Add GPT Image 2.5 Sunburst and quality selection for GPT Image models.
+- Add GLM-5.3 chat with streaming and tool-call support.
+
 ## [0.2.2] - 2026-09-11
 
 - Increase the default task wait timeout to 30 minutes for long video generation.

{everypixel_cli-0.2.2 → everypixel_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: everypixel-cli
-Version: 0.2.2
+Version: 0.3.0
 Summary: Official command line interface for Everypixel API
 Project-URL: Homepage, https://labs.everypixel.com
 Project-URL: Repository, https://github.com/everypixel/everypixel-cli
@@ -35,8 +35,8 @@ Description-Content-Type: text/markdown
 # Everypixel CLI
 
 Official command-line interface for the [Everypixel API](https://labs.everypixel.com/).
-Generate and edit images and videos, work with audio, run visual analysis, and
-automate Everypixel workflows from a terminal or an MCP client.
+Generate and edit images and videos, chat with GLM-5.3, work with audio, run
+visual analysis, and automate Everypixel workflows from a terminal or an MCP client.
 
 The CLI is designed for both people and agents: commands use readable terminal
 output by default and can return stable JSON for scripts and tool integrations.
@@ -181,6 +181,15 @@ to select their aspect ratio. Raster models also accept `--resolution`.
 
 `--lora-url` is supported only by `zimage`.
 
+GPT Image models are `gpt-image-2` and `gpt-image-2.5-sunburst`. Both generation
+and editing accept `--quality low|medium|high` (default: `medium`); Sunburst also
+supports `xhigh` and `max`. Use `--size square` with `--resolution 3k`.
+
+```bash
+everypixel image generate "a detailed botanical illustration" \
+  --model gpt-image-2.5-sunburst --quality high --download ./outputs
+```
+
 Grok image models are `grok-imagine`, `grok-imagine-2`, and
 `grok-imagine-2-low`. The `grok` alias remains supported. `grok_quality` and
 `wan22` have been removed from the API.
@@ -281,6 +290,37 @@ everypixel audio tts-create \
   --download ./outputs
 ```
 
+### Chat
+
+```bash
+everypixel chat "Explain how a rainbow forms."
+everypixel chat "Review this idea." --system "Be concise." --stream
+everypixel chat "Solve this problem." --reasoning-effort high --show-reasoning
+everypixel chat --input-file ./conversation.json --output-json
+```
+
+Chat uses the same credentials as other commands and requires the client's
+`chat` scope. The default model is `glm-5.3`. Each invocation sends one request;
+use `--input-file` for conversation history, function tools, or other API options:
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "What causes rainbows?"},
+    {"role": "assistant", "content": "Sunlight refracts and reflects in water droplets."},
+    {"role": "user", "content": "Why do the colors separate?"}
+  ],
+  "max_completion_tokens": 4096
+}
+```
+
+A positional prompt appends a user message to the supplied history. CLI options
+override matching fields in the file. `--stream` displays text as it arrives;
+JSON output returns one assembled response, including reasoning, tool calls,
+and usage. Function calls are returned for the caller to handle. The MCP `chat`
+tool accepts the same structured request and returns a complete response.
+Use `--request-timeout` to change the chat HTTP timeout (default: 240 seconds).
+
 ### Visual Analysis
 
 Analysis commands accept HTTP(S) URLs and local files. Local files are uploaded

{everypixel_cli-0.2.2 → everypixel_cli-0.3.0}/README.md

@@ -1,8 +1,8 @@
 # Everypixel CLI
 
 Official command-line interface for the [Everypixel API](https://labs.everypixel.com/).
-Generate and edit images and videos, work with audio, run visual analysis, and
-automate Everypixel workflows from a terminal or an MCP client.
+Generate and edit images and videos, chat with GLM-5.3, work with audio, run
+visual analysis, and automate Everypixel workflows from a terminal or an MCP client.
 
 The CLI is designed for both people and agents: commands use readable terminal
 output by default and can return stable JSON for scripts and tool integrations.
@@ -147,6 +147,15 @@ to select their aspect ratio. Raster models also accept `--resolution`.
 
 `--lora-url` is supported only by `zimage`.
 
+GPT Image models are `gpt-image-2` and `gpt-image-2.5-sunburst`. Both generation
+and editing accept `--quality low|medium|high` (default: `medium`); Sunburst also
+supports `xhigh` and `max`. Use `--size square` with `--resolution 3k`.
+
+```bash
+everypixel image generate "a detailed botanical illustration" \
+  --model gpt-image-2.5-sunburst --quality high --download ./outputs
+```
+
 Grok image models are `grok-imagine`, `grok-imagine-2`, and
 `grok-imagine-2-low`. The `grok` alias remains supported. `grok_quality` and
 `wan22` have been removed from the API.
@@ -247,6 +256,37 @@ everypixel audio tts-create \
   --download ./outputs
 ```
 
+### Chat
+
+```bash
+everypixel chat "Explain how a rainbow forms."
+everypixel chat "Review this idea." --system "Be concise." --stream
+everypixel chat "Solve this problem." --reasoning-effort high --show-reasoning
+everypixel chat --input-file ./conversation.json --output-json
+```
+
+Chat uses the same credentials as other commands and requires the client's
+`chat` scope. The default model is `glm-5.3`. Each invocation sends one request;
+use `--input-file` for conversation history, function tools, or other API options:
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "What causes rainbows?"},
+    {"role": "assistant", "content": "Sunlight refracts and reflects in water droplets."},
+    {"role": "user", "content": "Why do the colors separate?"}
+  ],
+  "max_completion_tokens": 4096
+}
+```
+
+A positional prompt appends a user message to the supplied history. CLI options
+override matching fields in the file. `--stream` displays text as it arrives;
+JSON output returns one assembled response, including reasoning, tool calls,
+and usage. Function calls are returned for the caller to handle. The MCP `chat`
+tool accepts the same structured request and returns a complete response.
+Use `--request-timeout` to change the chat HTTP timeout (default: 240 seconds).
+
 ### Visual Analysis
 
 Analysis commands accept HTTP(S) URLs and local files. Local files are uploaded

everypixel_cli-0.3.0/src/everypixel_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

everypixel_cli-0.3.0/src/everypixel_cli/application/chat.py

@@ -0,0 +1,192 @@
+"""Chat request construction and completion assembly without presentation code."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Iterator
+from typing import Any, Protocol
+
+from ..errors import APIResponseError, ValidationCLIError
+from ..schemas import ChatRequest
+from .models import ExecutionOptions, OperationResult
+
+
+class ChatClientProtocol(Protocol):
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        auth_required: bool = True,
+        timeout: float | None = None,
+    ) -> Any: ...
+
+    def stream_request(
+        self, method: str, path: str, *, json: dict[str, Any], timeout: float
+    ) -> Iterator[dict[str, Any]]: ...
+
+
+def build_chat_payload(
+    *,
+    payload: dict[str, Any],
+    prompt: str | None,
+    system: str | None,
+    options: dict[str, Any],
+) -> dict[str, Any]:
+    values = {
+        **payload,
+        **{key: value for key, value in options.items() if value is not None},
+    }
+    values.setdefault("model", "glm-5.3")
+    messages = values.get("messages", [])
+    if not isinstance(messages, list):
+        raise ValidationCLIError("messages must be an array")
+    messages = list(messages)
+    if system is not None:
+        messages.insert(0, {"role": "system", "content": system})
+    if prompt is not None:
+        messages.append({"role": "user", "content": prompt})
+    values["messages"] = messages
+    if values.get("stream") and "stream_options" not in values:
+        values["stream_options"] = {"include_usage": True}
+    return ChatRequest.model_validate(values).model_dump(mode="json", exclude_none=True)
+
+
+class ChatCompletion:
+    """Combine text, reasoning, and tool-call fragments into a completion."""
+
+    def __init__(self) -> None:
+        self.metadata: dict[str, Any] = {}
+        self.choices: dict[int, dict[str, Any]] = {}
+        self.tools: dict[int, dict[int, dict[str, Any]]] = {}
+
+    def add(self, event: dict[str, Any]) -> None:
+        choices = event.get("choices")
+        if not isinstance(choices, list):
+            raise APIResponseError("API returned invalid chat choices")
+        self.metadata.update(
+            {key: value for key, value in event.items() if key != "choices"}
+        )
+        for item in choices:
+            if not isinstance(item, dict):
+                raise APIResponseError("API returned an invalid chat choice")
+            index = item.get("index")
+            delta = item.get("delta")
+            if type(index) is not int or index < 0 or not isinstance(delta, dict):
+                raise APIResponseError("API returned an invalid chat delta")
+            choice = self.choices.setdefault(
+                index,
+                {
+                    "index": index,
+                    "message": {"role": "assistant", "content": None},
+                    "finish_reason": None,
+                },
+            )
+            choice.update(
+                {
+                    key: value
+                    for key, value in item.items()
+                    if key not in {"delta", "finish_reason"}
+                }
+            )
+            if item.get("finish_reason") is not None:
+                choice["finish_reason"] = item["finish_reason"]
+            message = choice["message"]
+            for key in ("content", "reasoning_content", "refusal"):
+                append_fragment(message, delta, key)
+            if "role" in delta:
+                message["role"] = delta["role"]
+            tool_calls = delta.get("tool_calls")
+            if tool_calls is not None:
+                self._add_tools(index, tool_calls)
+
+    def _add_tools(self, choice_index: int, calls: Any) -> None:
+        if not isinstance(calls, list):
+            raise APIResponseError("API returned invalid tool calls")
+        tools = self.tools.setdefault(choice_index, {})
+        for call in calls:
+            if not isinstance(call, dict):
+                raise APIResponseError("API returned an invalid tool call")
+            index = call.get("index")
+            if type(index) is not int or index < 0:
+                raise APIResponseError("API returned an invalid tool call index")
+            tool = tools.setdefault(index, {"function": {"name": "", "arguments": ""}})
+            append_fragment(tool, call, "id")
+            if "type" in call:
+                tool["type"] = call["type"]
+            function = call.get("function")
+            if function is not None:
+                if not isinstance(function, dict):
+                    raise APIResponseError("API returned an invalid function call")
+                for key in ("name", "arguments"):
+                    append_fragment(tool["function"], function, key)
+
+    def result(self) -> dict[str, Any]:
+        if not self.choices or any(
+            choice["finish_reason"] is None for choice in self.choices.values()
+        ):
+            raise APIResponseError("API returned an unfinished chat completion")
+        for index, tools in self.tools.items():
+            self.choices[index]["message"]["tool_calls"] = [
+                tools[key] for key in sorted(tools)
+            ]
+        return {
+            **self.metadata,
+            "object": "chat.completion",
+            "choices": [self.choices[index] for index in sorted(self.choices)],
+        }
+
+
+def append_fragment(target: dict[str, Any], delta: dict[str, Any], key: str) -> None:
+    value = delta.get(key)
+    if value is None:
+        return
+    if not isinstance(value, str):
+        raise APIResponseError("API returned an invalid chat text fragment")
+    target[key] = (target.get(key) or "") + value
+
+
+class ChatService:
+    def __init__(self, client: ChatClientProtocol) -> None:
+        self.client = client
+
+    def execute(
+        self,
+        payload: dict[str, Any],
+        *,
+        request_timeout: float = 240.0,
+        execution: ExecutionOptions | None = None,
+        on_chunk: Callable[[dict[str, Any]], None] | None = None,
+    ) -> OperationResult:
+        if not math.isfinite(request_timeout) or request_timeout <= 0:
+            raise ValidationCLIError("request timeout must be a finite positive number")
+        execution = execution or ExecutionOptions()
+        execution.check_cancelled()
+        if not payload.get("stream"):
+            value = self.client.request(
+                "POST", "/v1/chat/completions", json=payload, timeout=request_timeout
+            )
+            execution.check_cancelled()
+            return OperationResult(value=value)
+        completion = ChatCompletion()
+        events = self.client.stream_request(
+            "POST", "/v1/chat/completions", json=payload, timeout=request_timeout
+        )
+        # Closing the generator also closes its HTTP response on cancellation
+        # or a rendering failure, without starting another generation.
+        try:
+            for event in events:
+                execution.check_cancelled()
+                completion.add(event)
+                if on_chunk is not None:
+                    on_chunk(event)
+                execution.check_cancelled()
+        finally:
+            close = getattr(events, "close", None)
+            if close is not None:
+                close()
+        execution.check_cancelled()
+        return OperationResult(value=completion.result())

{everypixel_cli-0.2.2 → everypixel_cli-0.3.0}/src/everypixel_cli/application/services.py

@@ -33,6 +33,8 @@ from ..openapi import (
     validate_payload_against_operation,
 )
 from ..schemas import (
+    ChatRequest,
+    GPT_IMAGE_MODEL_QUALITIES,
     ImageEditPayload,
     ImageGeneratePayload,
     ImageUpscalePayload,
@@ -46,7 +48,9 @@ from ..schemas import (
     VideoGenerateModel,
     VideoUpscalePayload,
     normalize_grok_model,
+    normalize_image_quality,
 )
+from .chat import ChatClientProtocol, ChatService, build_chat_payload
 from .models import (
     ExecutionOptions,
     OperationCancelled,
@@ -61,22 +65,11 @@ _VIDEO_GENERATE_ADAPTER: TypeAdapter[VideoGenerateRequest] = TypeAdapter(
 _VIDEO_EDIT_ADAPTER: TypeAdapter[VideoEditRequest] = TypeAdapter(VideoEditRequest)
 
 
-class EverypixelClientProtocol(Protocol):
+class EverypixelClientProtocol(ChatClientProtocol, Protocol):
     """Small infrastructure seam used by application services."""
 
     base_url: str
 
-    def request(
-        self,
-        method: str,
-        path: str,
-        *,
-        json: dict[str, Any] | None = None,
-        params: dict[str, Any] | None = None,
-        files: dict[str, Any] | None = None,
-        auth_required: bool = True,
-    ) -> Any: ...
-
     def get_status(self, task_id: str) -> Any: ...
 
     def check_auth(self) -> None: ...
@@ -837,6 +830,7 @@ class ApplicationServices:
         execution: ExecutionOptions,
         lora_url: str | None = None,
         controls: dict[str, Any] | str | None = None,
+        quality: str | None = None,
     ) -> OperationResult:
         payload = build_image_generate_payload(
             prompt=prompt,
@@ -849,6 +843,7 @@ class ApplicationServices:
             callback_url=callback_url,
             lora_url=lora_url,
             controls=controls,
+            quality=quality,
         )
         return self._execute_async(
             endpoint="/v1/image_generate",
@@ -888,6 +883,7 @@ class ApplicationServices:
         callback_url: str | None,
         execution: ExecutionOptions,
         megapixel_ratio: float = 1.0,
+        quality: str | None = None,
     ) -> OperationResult:
         payload = build_image_edit_payload(
             prompt=prompt,
@@ -896,6 +892,7 @@ class ApplicationServices:
             image_size=image_size,
             resolution=resolution,
             megapixel_ratio=megapixel_ratio,
+            quality=quality,
             seed=seed,
             callback_url=callback_url,
         )
@@ -1225,6 +1222,45 @@ class ApplicationServices:
             fallback_extension=".mp3",
         )
 
+    def execute_chat(
+        self,
+        *,
+        prompt: str | None = None,
+        system: str | None = None,
+        input_file: Path | None = None,
+        payload: dict[str, Any] | None = None,
+        model: str | None = None,
+        stream: bool | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        reasoning_effort: str | None = None,
+        request_timeout: float = 240.0,
+        execution: ExecutionOptions | None = None,
+        on_chunk: Callable[[dict[str, Any]], None] | None = None,
+    ) -> OperationResult:
+        inputs = parse_generic_payload(prompt=None, items=[], input_file=input_file)
+        inputs.update(payload or {})
+        request = build_chat_payload(
+            payload=inputs,
+            prompt=prompt,
+            system=system,
+            options={
+                "model": model,
+                "stream": stream,
+                "max_completion_tokens": max_completion_tokens,
+                "temperature": temperature,
+                "top_p": top_p,
+                "reasoning_effort": reasoning_effort,
+            },
+        )
+        return ChatService(self._operations.client).execute(
+            request,
+            request_timeout=request_timeout,
+            execution=execution,
+            on_chunk=on_chunk,
+        )
+
     def get_task_status(
         self, *, task_id: str, execution: ExecutionOptions
     ) -> OperationResult:
@@ -1276,6 +1312,21 @@ class ApplicationServices:
             )
         if path in {"/v1/image_generate", "/v1/image_edit", "/v1/video_generate"}:
             payload = normalize_grok_model(payload)
+        if path in {"/v1/image_generate", "/v1/image_edit"}:
+            try:
+                payload = normalize_image_quality(payload)
+            except ValueError as exc:
+                raise ValidationCLIError(str(exc)) from exc
+            if (
+                isinstance(payload.get("model"), str)
+                and payload["model"] in GPT_IMAGE_MODEL_QUALITIES
+            ):
+                image_schema = (
+                    ImageGeneratePayload
+                    if path == "/v1/image_generate"
+                    else ImageEditPayload
+                )
+                image_schema.model_validate(payload, extra="ignore")
         if path == "/v1/video_generate" and payload.get("model") in get_args(
             VideoGenerateModel
         ):
@@ -1287,6 +1338,8 @@ class ApplicationServices:
             # specialized model does not know yet; validate known semantics
             # without rewriting or narrowing their payload.
             _VIDEO_EDIT_ADAPTER.validate_python(payload, extra="ignore")
+        if path == "/v1/chat/completions":
+            ChatRequest.model_validate(payload, extra="ignore")
         validate_payload_against_operation(operation, payload)
         if dry_run:
             return OperationResult(
@@ -1300,6 +1353,10 @@ class ApplicationServices:
                     "schema_source": schema_source,
                 }
             )
+        if path == "/v1/chat/completions" and resolved_method == "POST":
+            return ChatService(self._operations.client).execute(
+                payload, execution=execution
+            )
         return self._operations.execute(
             OperationRequest(
                 endpoint=path,

{everypixel_cli-0.2.2 → everypixel_cli-0.3.0}/src/everypixel_cli/cli.py

@@ -48,7 +48,7 @@ from .errors import (
     normalize_exception,
 )
 from .openapi import load_schema
-from .output import emit_error, emit_human, emit_json
+from .output import ChatRenderer, emit_error, emit_human, emit_json
 
 
 def json_output_requested(args: Sequence[str]) -> bool:
@@ -395,11 +395,20 @@ def stop_with_error(ctx: typer.Context, exc: Exception) -> NoReturn:
     raise typer.Exit(error.exit_code) from exc
 
 
-def run_action(ctx: typer.Context, action: Callable[[], Any]) -> None:
+def run_action(
+    ctx: typer.Context,
+    action: Callable[[], Any],
+    *,
+    render: Callable[[Any], None] | None = None,
+) -> None:
     """Run a command action and handle all expected application errors."""
 
     try:
-        finish(ctx, action())
+        value = action()
+        if render is None:
+            finish(ctx, value)
+        else:
+            render(value)
     except typer.Exit:
         raise
     except (
@@ -430,6 +439,83 @@ def apply_common_options(
     return runtime
 
 
+@app.command("chat")
+def chat(
+    ctx: typer.Context,
+    prompt: Annotated[
+        Optional[str], typer.Argument(help="User message to append.")
+    ] = None,
+    system: Annotated[
+        Optional[str], typer.Option("--system", help="System instruction.")
+    ] = None,
+    input_file: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--input-file",
+            help="JSON request with messages, tools, and other chat options.",
+        ),
+    ] = None,
+    model: Annotated[
+        Optional[str], typer.Option("--model", help="Chat model (default: glm-5.3).")
+    ] = None,
+    stream: Annotated[
+        Optional[bool],
+        typer.Option("--stream/--no-stream", help="Stream the response."),
+    ] = None,
+    max_completion_tokens: Annotated[
+        Optional[int], typer.Option("--max-completion-tokens")
+    ] = None,
+    temperature: Annotated[Optional[float], typer.Option("--temperature")] = None,
+    top_p: Annotated[Optional[float], typer.Option("--top-p")] = None,
+    reasoning_effort: Annotated[
+        Optional[str], typer.Option("--reasoning-effort", help="low, high, or max.")
+    ] = None,
+    show_reasoning: Annotated[
+        bool,
+        typer.Option("--show-reasoning", help="Include reasoning in human output."),
+    ] = False,
+    request_timeout: Annotated[
+        float,
+        typer.Option(
+            "--request-timeout",
+            callback=positive_float,
+            help="HTTP timeout in seconds.",
+        ),
+    ] = 240.0,
+    output_json: OutputJsonOption = False,
+    jq_expr: JqOption = None,
+) -> None:
+    """Chat with GLM-5.3 using a prompt or a JSON conversation."""
+
+    runtime = apply_common_options(ctx, output_json=output_json, jq_expr=jq_expr)
+    renderer = ChatRenderer(show_reasoning=show_reasoning, no_color=runtime.no_color)
+
+    def render(result: Any) -> None:
+        if runtime.output_json:
+            finish(ctx, result)
+        else:
+            renderer.finish(serialize_operation_result(result))
+
+    run_action(
+        ctx,
+        lambda: runtime.services().execute_chat(
+            prompt=prompt,
+            system=system,
+            input_file=input_file,
+            model=model,
+            stream=stream,
+            max_completion_tokens=max_completion_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            reasoning_effort=reasoning_effort,
+            request_timeout=request_timeout,
+            execution=runtime.execution_options(),
+            on_chunk=None if runtime.output_json else renderer.chunk,
+        ),
+        render=render,
+    )
+
+
 @auth_app.command("configure")
 def auth_configure(
     ctx: typer.Context,
@@ -584,6 +670,13 @@ def image_generate(
         typer.Option("--controls", help="Recraft palette controls as JSON."),
     ] = None,
     resolution: Annotated[Optional[str], typer.Option("--resolution")] = None,
+    quality: Annotated[
+        Optional[str],
+        typer.Option(
+            "--quality",
+            help="GPT Image quality: low, medium, high; 2.5 also xhigh, max.",
+        ),
+    ] = None,
     seed: Annotated[int, typer.Option("--seed")] = -1,
     callback_url: Annotated[Optional[str], typer.Option("--callback-url")] = None,
     wait_option: WaitOption = None,
@@ -611,6 +704,7 @@ def image_generate(
             lora_url=lora_url,
             controls=controls,
             resolution=resolution,
+            quality=quality,
             seed=seed,
             callback_url=callback_url,
             execution=runtime.execution_options(),
@@ -630,6 +724,13 @@ def image_edit(
     size: Annotated[Optional[str], typer.Option("--size")] = None,
     resolution: Annotated[Optional[str], typer.Option("--resolution")] = None,
     megapixel_ratio: Annotated[float, typer.Option("--megapixel-ratio")] = 1.0,
+    quality: Annotated[
+        Optional[str],
+        typer.Option(
+            "--quality",
+            help="GPT Image quality: low, medium, high; 2.5 also xhigh, max.",
+        ),
+    ] = None,
     seed: Annotated[int, typer.Option("--seed")] = -1,
     callback_url: Annotated[Optional[str], typer.Option("--callback-url")] = None,
     wait_option: WaitOption = None,
@@ -655,6 +756,7 @@ def image_edit(
             image_size=size,
             resolution=resolution,
             megapixel_ratio=megapixel_ratio,
+            quality=quality,
             seed=seed,
             callback_url=callback_url,
             execution=runtime.execution_options(),