pygeai 0.6.0b7__py3-none-any.whl → 0.6.0b11__py3-none-any.whl

pygeai/cli/commands/chat.py

@@ -52,6 +52,7 @@ def get_chat_completion(option_list: list):
     store = None
     metadata = None
     user = None
+    reasoning_effort = None
 
     for option_flag, option_arg in option_list:
         if option_flag.name == "model":
@@ -124,6 +125,8 @@ def get_chat_completion(option_list: list):
                 raise WrongArgumentError("metadata must be a valid JSON object")
         if option_flag.name == "user":
             user = option_arg
+        if option_flag.name == "reasoning_effort":
+            reasoning_effort = option_arg
 
     messages = get_messages(message_list)
 
@@ -151,7 +154,8 @@ def get_chat_completion(option_list: list):
         stream_options=stream_options,
         store=store,
         metadata=metadata,
-        user=user
+        user=user,
+        reasoning_effort=reasoning_effort
     )
     if stream:
         Console.write_stdout("Streaming chat completion:")
@@ -295,6 +299,14 @@ chat_completion_options = [
         "Optional string identifier for the end-user to monitor abuse.",
         True
     ),
+    Option(
+        "reasoning_effort",
+        ["--reasoning-effort"],
+        "Optional string to control the depth of reasoning applied by supported models. "
+        "Possible values: 'low', 'medium', 'high'. Supported by OpenAI models from version 5, "
+        "Claude models from version 4.1, and Gemini models from version 2.0.",
+        True
+    ),
 ]
 
 
@@ -649,6 +661,297 @@ generate_image_options = [
 ]
 
 
+def get_edit_image(option_list: list):
+    model = None
+    prompt = None
+    image = None
+    size = None
+    n = 1
+    quality = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "model":
+            model = option_arg
+        if option_flag.name == "prompt":
+            prompt = option_arg
+        if option_flag.name == "image":
+            image = option_arg
+        if option_flag.name == "size":
+            size = option_arg
+        if option_flag.name == "n":
+            try:
+                n = int(option_arg)
+                if n < 1 or n > 10:
+                    raise WrongArgumentError("n must be an integer between 1 and 10.")
+            except ValueError:
+                raise WrongArgumentError("n must be a valid integer.")
+        if option_flag.name == "quality":
+            quality = option_arg
+
+    if not (model and prompt and image and size):
+        raise MissingRequirementException("Cannot edit image without specifying model, prompt, image, and size.")
+
+    client = ChatClient()
+    try:
+        result = client.edit_image(
+            model=model,
+            prompt=prompt,
+            image=image,
+            size=size,
+            n=n,
+            quality=quality
+        )
+        Console.write_stdout(f"Image editing result: \n{result}\n")
+    except Exception as e:
+        logger.error(f"Error editing image: {e}")
+        Console.write_stderr(f"Failed to edit image: {e}")
+
+
+edit_image_options = [
+    Option(
+        "model",
+        ["--model", "-m"],
+        "The model specification for image editing, e.g., 'openai/gpt-image-1'.",
+        True
+    ),
+    Option(
+        "prompt",
+        ["--prompt", "-p"],
+        "Description of the desired edit, e.g., 'remove the ball'.",
+        True
+    ),
+    Option(
+        "image",
+        ["--image", "-img"],
+        "URL of the image to be edited, e.g., 'https://example.com/image.jpg'.",
+        True
+    ),
+    Option(
+        "size",
+        ["--size", "-s"],
+        "Desired dimensions of the output image in pixels, e.g., '1024x1024'.",
+        True
+    ),
+    Option(
+        "n",
+        ["--n"],
+        "Number of edited images to generate (1-10, depending on the model). Default is 1.",
+        True
+    ),
+    Option(
+        "quality",
+        ["--quality", "-q"],
+        "Rendering quality, e.g., 'high', 'medium', 'low'.",
+        True
+    ),
+]
+
+
+def get_response(option_list: list):
+    model = None
+    input_text = None
+    files = None
+    tools = None
+    tool_choice = None
+    temperature = None
+    max_output_tokens = None
+    top_p = None
+    metadata = None
+    user = None
+    instructions = None
+    reasoning = None
+    truncation = None
+    parallel_tool_calls = None
+    store = None
+    stream = False
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "model":
+            model = option_arg
+        if option_flag.name == "input":
+            input_text = option_arg
+        if option_flag.name == "files":
+            try:
+                files = json.loads(option_arg) if option_arg else None
+                if files and not isinstance(files, list):
+                    raise WrongArgumentError("files must be a JSON array of file paths")
+            except json.JSONDecodeError:
+                raise WrongArgumentError("files must be a valid JSON array")
+        if option_flag.name == "tools":
+            try:
+                tools = json.loads(option_arg) if option_arg else None
+            except json.JSONDecodeError:
+                raise WrongArgumentError("tools must be a valid JSON array")
+        if option_flag.name == "tool_choice":
+            try:
+                tool_choice = json.loads(option_arg) if option_arg else None
+            except json.JSONDecodeError:
+                tool_choice = option_arg
+        if option_flag.name == "temperature":
+            temperature = float(option_arg) if option_arg is not None else None
+        if option_flag.name == "max_output_tokens":
+            max_output_tokens = int(option_arg) if option_arg is not None else None
+        if option_flag.name == "top_p":
+            top_p = float(option_arg) if option_arg else None
+        if option_flag.name == "metadata":
+            try:
+                metadata = json.loads(option_arg) if option_arg else None
+            except json.JSONDecodeError:
+                raise WrongArgumentError("metadata must be a valid JSON object")
+        if option_flag.name == "user":
+            user = option_arg
+        if option_flag.name == "instructions":
+            instructions = option_arg
+        if option_flag.name == "reasoning":
+            try:
+                reasoning = json.loads(option_arg) if option_arg else None
+            except json.JSONDecodeError:
+                raise WrongArgumentError("reasoning must be a valid JSON object")
+        if option_flag.name == "truncation":
+            truncation = option_arg
+        if option_flag.name == "parallel_tool_calls":
+            parallel_tool_calls = get_boolean_value(option_arg) if option_arg else None
+        if option_flag.name == "store":
+            store = get_boolean_value(option_arg) if option_arg else None
+        if option_flag.name == "stream":
+            if option_arg:
+                stream = get_boolean_value(option_arg)
+
+    if not (model and input_text):
+        raise MissingRequirementException("Cannot get response without specifying model and input")
+
+    client = ChatClient()
+    try:
+        result = client.get_response(
+            model=model,
+            input=input_text,
+            files=files,
+            tools=tools,
+            tool_choice=tool_choice,
+            temperature=temperature,
+            max_output_tokens=max_output_tokens,
+            top_p=top_p,
+            metadata=metadata,
+            user=user,
+            instructions=instructions,
+            reasoning=reasoning,
+            truncation=truncation,
+            parallel_tool_calls=parallel_tool_calls,
+            store=store,
+            stream=stream
+        )
+        if stream:
+            Console.write_stdout("Streaming response:")
+            for chunk in result:
+                Console.write_stdout(f"{chunk}", end="")
+                sys.stdout.flush()
+            Console.write_stdout()
+        else:
+            Console.write_stdout(f"Response result: \n{json.dumps(result, indent=2)}\n")
+    except Exception as e:
+        logger.error(f"Error getting response: {e}")
+        Console.write_stderr(f"Failed to get response: {e}")
+
+
+response_options = [
+    Option(
+        "model",
+        ["--model", "-m"],
+        "The model specification, e.g., 'openai/o1-pro'.",
+        True
+    ),
+    Option(
+        "input",
+        ["--input", "-i"],
+        "The user input text.",
+        True
+    ),
+    Option(
+        "files",
+        ["--files", "-f"],
+        "JSON array of file paths (images or PDFs) to include in the request, e.g., '[\"image.jpg\", \"doc.pdf\"]'.",
+        True
+    ),
+    Option(
+        "tools",
+        ["--tools"],
+        "Optional JSON array of tools (e.g., functions) the model may call.",
+        True
+    ),
+    Option(
+        "tool_choice",
+        ["--tool-choice"],
+        "Optional string (e.g., \"none\", \"auto\") or JSON object to control which tool is called.",
+        True
+    ),
+    Option(
+        "temperature",
+        ["--temperature", "--temp"],
+        "Float value to set randomness of the response (between 0 and 2).",
+        True
+    ),
+    Option(
+        "max_output_tokens",
+        ["--max-output-tokens"],
+        "Integer value to set max tokens in the output.",
+        True
+    ),
+    Option(
+        "top_p",
+        ["--top-p"],
+        "Optional float value for nucleus sampling (between 0 and 1).",
+        True
+    ),
+    Option(
+        "metadata",
+        ["--metadata"],
+        "Optional JSON object with up to 16 key-value pairs to attach to the object.",
+        True
+    ),
+    Option(
+        "user",
+        ["--user"],
+        "Optional string identifier for the end-user.",
+        True
+    ),
+    Option(
+        "instructions",
+        ["--instructions"],
+        "Optional additional instructions for the model.",
+        True
+    ),
+    Option(
+        "reasoning",
+        ["--reasoning"],
+        "Optional JSON object for reasoning configuration, e.g., {\"effort\": \"medium\"}.",
+        True
+    ),
+    Option(
+        "truncation",
+        ["--truncation"],
+        "Optional truncation strategy, e.g., \"disabled\".",
+        True
+    ),
+    Option(
+        "parallel_tool_calls",
+        ["--parallel-tool-calls"],
+        "Optional boolean to enable parallel tool calls. Possible values: 0: OFF; 1: ON",
+        True
+    ),
+    Option(
+        "store",
+        ["--store"],
+        "Optional boolean to store the output. Possible values: 0: OFF; 1: ON",
+        True
+    ),
+    Option(
+        "stream",
+        ["--stream"],
+        "Whether to stream the response. Possible values: 0: OFF; 1: ON",
+        True
+    ),
+]
+
 chat_commands = [
     Command(
         "help",
@@ -695,5 +998,23 @@ chat_commands = [
         [],
         generate_image_options
     ),
+    Command(
+        "edit_image",
+        ["edit-image", "edit-img"],
+        "Edit an existing image using the specified model and parameters",
+        get_edit_image,
+        ArgumentsEnum.REQUIRED,
+        [],
+        edit_image_options
+    ),
+    Command(
+        "response",
+        ["response", "resp"],
+        "Get a response using the Responses API with support for images and PDFs",
+        get_response,
+        ArgumentsEnum.REQUIRED,
+        [],
+        response_options
+    ),
 
 ]

pygeai/cli/commands/embeddings.py

@@ -1,5 +1,7 @@
+import json
 from pygeai.cli.commands import Command, Option, ArgumentsEnum
 from pygeai.cli.commands.builders import build_help_text
+from pygeai.cli.commands.common import get_boolean_value
 from pygeai.cli.texts.help import EMBEDDINGS_HELP_TEXT
 from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
 from pygeai.core.embeddings.clients import EmbeddingsClient
@@ -22,6 +24,7 @@ def generate_embeddings(option_list: list):
     input_type = None
     timeout = None
     cache = None
+    preview = True
     input_list = list()
 
     for option_flag, option_arg in option_list:
@@ -32,18 +35,23 @@ def generate_embeddings(option_list: list):
         if option_flag.name == "encoding_format":
             encoding_format = option_arg
         if option_flag.name == "dimensions":
-            dimensions = option_arg
+            try:
+                dimensions = int(option_arg)
+            except (ValueError, TypeError):
+                raise WrongArgumentError("dimensions must be an integer")
         if option_flag.name == "user":
             user = option_arg
         if option_flag.name == "input_type":
             input_type = option_arg
         if option_flag.name == "timeout":
-            timeout = option_arg
+            try:
+                timeout = int(option_arg)
+            except (ValueError, TypeError):
+                raise WrongArgumentError("timeout must be an integer")
         if option_flag.name == "cache":
-            if not str(option_arg).isdigit() or int(option_arg) not in [0, 1]:
-                raise WrongArgumentError("If specified, cache must be 0 or 1")
-
-            cache = bool(int(option_arg))
+            cache = get_boolean_value(option_arg)
+        if option_flag.name == "preview":
+            preview = get_boolean_value(option_arg)
 
     if not (model and any(input_list)):
         raise MissingRequirementException("Cannot generate embeddings without specifying model and at least one input")
@@ -59,7 +67,40 @@ def generate_embeddings(option_list: list):
         timeout=timeout,
         cache=cache
     )
-    Console.write_stdout(f"Embeddings detail: \n{result}")
+    
+    output = {
+        "model": result.get("model"),
+        "object": result.get("object"),
+        "embeddings_count": len(result.get("data", [])),
+        "usage": result.get("usage"),
+        "data": []
+    }
+    
+    for item in result.get("data", []):
+        embedding_data = item.get("embedding")
+        if isinstance(embedding_data, list):
+            embedding_info = {
+                "index": item.get("index"),
+                "dimensions": len(embedding_data),
+                "object": item.get("object")
+            }
+            if preview:
+                embedding_info["preview"] = embedding_data[:5] if len(embedding_data) > 5 else embedding_data
+            else:
+                embedding_info["embedding"] = embedding_data
+        else:
+            embedding_info = {
+                "index": item.get("index"),
+                "object": item.get("object"),
+                "format": "base64"
+            }
+            if preview:
+                embedding_info["preview"] = str(embedding_data)[:50] + "..." if len(str(embedding_data)) > 50 else embedding_data
+            else:
+                embedding_info["embedding"] = embedding_data
+        output["data"].append(embedding_info)
+    
+    Console.write_stdout(json.dumps(output, indent=2))
 
 
 generate_embeddings_options = [
@@ -109,10 +150,17 @@ generate_embeddings_options = [
     Option(
         "cache",
         ["--cache"],
-        "Enable X-Saia-Cache-Enabled to cache the embeddings for the model; it applies by Organization/Project."
+        "Enable X-Saia-Cache-Enabled to cache the embeddings for the model; it applies by Organization/Project. "
         "1 to set to True and 0 to false. 0 is default",
         True
     ),
+    Option(
+        "preview",
+        ["--preview"],
+        "Control embedding display in output. 1 (default) shows a preview (first 5 values for float, 50 chars for base64). "
+        "0 shows the full embedding vector. Use 0 to get complete embeddings for further processing",
+        True
+    ),
 
 ]