janito 2.17.0__tar.gz → 2.18.0__tar.gz

{janito-2.17.0 → janito-2.18.0}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [2.18.0] - 2025-08-07
+
+### Added
+
+- Added OpenAI GPT-5 models (gpt-5, gpt-5-mini, gpt-5-nano) and set default model to gpt-5
+- Chat session: improved backend hostname detection
+- Cleaned up test file
+
 ## [2.17.0] - 2025-08-05
 
 ### Added

{janito-2.17.0 → janito-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.17.0
+Version: 2.18.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-2.17.0 → janito-2.18.0}/docs/cerebras-setup.md

@@ -42,6 +42,23 @@ janito -p cerebras -m qwen-3-coder-480b "Explain quantum computing"
 
 Cerebras offers several models through their API:
 
+**Production Models:**
+
+- `llama-4-scout-17b-16e-instruct`
+- `llama-3.3-70b`
+- `llama3.1-8b`
+- `qwen-3-32b`
+
+**Preview Models:**
+
+- `llama-4-maverick-17b-128e-instruct`
+- `qwen-3-235b-a22b-instruct-2507`
+- `qwen-3-235b-a22b-thinking-2507`
+- `qwen-3-coder-480b`
+- `gpt-oss-120b`
+
+**Notes:**
+
 - `qwen-3-coder-480b`: 32k context, reasoning-focused model with function calling support
 
 ## Troubleshooting

janito-2.18.0/docs/openai-setup.md

@@ -0,0 +1,85 @@
+# OpenAI Setup Guide
+
+This guide will help you set up Janito to work with OpenAI's models.
+
+## Prerequisites
+
+1. An OpenAI account
+2. An API key from OpenAI
+
+## Getting an API Key
+
+1. Go to [OpenAI's API Keys page](https://platform.openai.com/api-keys)
+2. Sign in to your OpenAI account
+3. Click on "Create new secret key"
+4. Copy the generated key and save it in a secure location
+
+## Configuration
+
+You can configure your OpenAI API key in several ways:
+
+### Option 1: Using the CLI
+
+```bash
+janito --set-api-key openai YOUR_API_KEY
+```
+
+### Option 2: Environment Variable
+
+Set the `OPENAI_API_KEY` environment variable:
+
+```bash
+export OPENAI_API_KEY=YOUR_API_KEY
+```
+
+On Windows:
+```cmd
+set OPENAI_API_KEY=YOUR_API_KEY
+```
+
+### Option 3: Configuration File
+
+Add the following to your Janito configuration file:
+
+```yaml
+providers:
+  openai:
+    api_key: YOUR_API_KEY
+```
+
+## Available Models
+
+Janito supports the following OpenAI models:
+
+- GPT-5 (default)
+- GPT-5 Mini
+- GPT-5 Nano
+- GPT-4
+- GPT-4 Turbo
+- GPT-3.5 Turbo
+
+## Usage
+
+After configuration, you can use OpenAI models with Janito:
+
+```bash
+# Use the default model (GPT-5)
+janito "Explain quantum computing"
+
+# Specify a specific model
+janito -m gpt-4 "Explain quantum computing"
+
+# Use in chat mode
+janito -c
+
+# Use in chat mode with a specific model
+janito -c -m gpt-4-turbo
+```
+
+## Troubleshooting
+
+If you encounter issues:
+
+1. Verify your API key is correct and active
+2. Check that you have sufficient credits in your OpenAI account
+3. Ensure your network connection can reach OpenAI's API endpoints

{janito-2.17.0 → janito-2.18.0}/docs/supported-providers-models.md

@@ -4,9 +4,14 @@ This page lists the supported providers and their available models.
 
 ## OpenAI
 
-- GPT-3.5 Turbo
+- GPT-5 (default)
+- GPT-5 Mini
+- GPT-5 Nano
 - GPT-4
 - GPT-4 Turbo
+- GPT-3.5 Turbo
+
+For setup instructions, see the [OpenAI Setup Guide](openai-setup.md).
 
 ## Google
 
@@ -47,12 +52,14 @@ This page lists the supported providers and their available models.
 ## Cerebras
 
 **Production Models:**
+
 - llama-4-scout-17b-16e-instruct
 - llama-3.3-70b
 - llama3.1-8b
 - qwen-3-32b
 
 **Preview Models:**
+
 - llama-4-maverick-17b-128e-instruct
 - qwen-3-235b-a22b-instruct-2507
 - qwen-3-235b-a22b-thinking-2507
@@ -60,6 +67,7 @@ This page lists the supported providers and their available models.
 - gpt-oss-120b
 
 **Notes:**
+
 - qwen-3-coder-480b: 32k context, reasoning-focused model with function calling support
 
 <!-- Removed links to model_info.py files for all providers to avoid broken references. -->

{janito-2.17.0 → janito-2.18.0}/janito/cli/chat_mode/session.py

@@ -296,21 +296,39 @@ class ChatSession:
                 else "Unknown"
             )
 
-            # Get backend hostname if available
             backend_hostname = "Unknown"
-            if hasattr(self.agent, "driver") and self.agent.driver:
-                if hasattr(self.agent.driver, "config") and hasattr(
-                    self.agent.driver.config, "base_url"
-                ):
-                    base_url = self.agent.driver.config.base_url
-                    if base_url:
-                        try:
-                            from urllib.parse import urlparse
-
-                            parsed = urlparse(base_url)
-                            backend_hostname = parsed.netloc
-                        except Exception:
-                            backend_hostname = base_url
+            candidates = []
+            drv = getattr(self.agent, "driver", None)
+            if drv is not None:
+                cfg = getattr(drv, "config", None)
+                if cfg is not None:
+                    b = getattr(cfg, "base_url", None)
+                    if b:
+                        candidates.append(b)
+                direct_base = getattr(drv, "base_url", None)
+                if direct_base:
+                    candidates.append(direct_base)
+            cfg2 = getattr(self.agent, "config", None)
+            if cfg2 is not None:
+                b2 = getattr(cfg2, "base_url", None)
+                if b2:
+                    candidates.append(b2)
+            top_base = getattr(self.agent, "base_url", None)
+            if top_base:
+                candidates.append(top_base)
+            from urllib.parse import urlparse
+            for candidate in candidates:
+                try:
+                    if not candidate:
+                        continue
+                    parsed = urlparse(str(candidate))
+                    host = parsed.netloc or parsed.path
+                    if host:
+                        backend_hostname = host
+                        break
+                except Exception:
+                    backend_hostname = str(candidate)
+                    break
 
             self.console.print(
                 Rule(

{janito-2.17.0 → janito-2.18.0}/janito/providers/openai/model_info.py

@@ -111,6 +111,39 @@ MODEL_SPECS = {
         open="openai",
         driver="OpenAIModelDriver",
     ),
+    "gpt-5": LLMModelInfo(
+        name="gpt-5",
+        context=200000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=100000,
+        thinking_supported=True,
+        default_temp=1.0,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-5-mini": LLMModelInfo(
+        name="gpt-5-mini",
+        context=200000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=100000,
+        thinking_supported=True,
+        default_temp=1.0,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-5-nano": LLMModelInfo(
+        name="gpt-5-nano",
+        context=200000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=100000,
+        thinking_supported=True,
+        default_temp=1.0,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
     # duplicated gpt-4-turbo with minimal properties for distinction
     "gpt-4-turbo-alt": LLMModelInfo(
         name="gpt-4-turbo",

{janito-2.17.0 → janito-2.18.0}/janito/providers/openai/provider.py

@@ -17,7 +17,7 @@ class OpenAIProvider(LLMProvider):
     NAME = "openai"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini,
+    DEFAULT_MODEL = "gpt-5"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, gpt-5, gpt-5-nano
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

{janito-2.17.0 → janito-2.18.0}/janito/tools/adapters/local/read_files.py

@@ -52,4 +52,4 @@ class ReadFilesTool(ToolBase):
                 results.append(
                     f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
                 )
-        return "\n".join(results)
+        return "\n".join(results)

{janito-2.17.0 → janito-2.18.0}/janito/tools/path_security.py

@@ -135,6 +135,7 @@ def _extract_path_keys_from_schema(schema: Mapping[str, Any]) -> set[str]:
     path_keys: set[str] = set()
     if schema is not None:
         for k, v in schema.get("properties", {}).items():
+            # Handle direct path strings
             if v.get("format") == "path" or (
                 v.get("type") == "string"
                 and (
@@ -144,6 +145,19 @@ def _extract_path_keys_from_schema(schema: Mapping[str, Any]) -> set[str]:
                 )
             ):
                 path_keys.add(k)
+            # Handle arrays of path strings
+            elif v.get("type") == "array" and "items" in v:
+                items = v["items"]
+                if items.get("format") == "path" or (
+                    items.get("type") == "string"
+                    and (
+                        "path" in items.get("description", "").lower()
+                        or "path" in v.get("description", "").lower()
+                        or k.endswith("paths")
+                        or k == "paths"
+                    )
+                ):
+                    path_keys.add(k)
     return path_keys
 
 

{janito-2.17.0 → janito-2.18.0}/janito/tools/tools_adapter.py

@@ -131,9 +131,15 @@ class ToolsAdapterBase:
 
         if arguments is None:
             arguments = {}
-        # Ensure the input is a dict to avoid breaking the inspect-based logic
+        # If arguments are provided as a non-dict (e.g. a list or a scalar)
+        # we skip signature *keyword* validation completely and defer the
+        # decision to Python's own call mechanics when the function is
+        # eventually invoked.  This allows positional / variadic arguments to
+        # be supplied by callers that intentionally bypass the structured
+        # JSON-schema style interface.
         if not isinstance(arguments, dict):
-            return "Tool arguments should be provided as an object / mapping"
+            # Nothing to validate at this stage – treat as OK.
+            return None
 
         sig = inspect.signature(func)
         params = sig.parameters
@@ -193,30 +199,32 @@ class ToolsAdapterBase:
             )
 
             schema = getattr(tool, "schema", None)
-            try:
-                validate_paths_in_arguments(arguments, workdir, schema=schema)
-            except PathSecurityError as sec_err:
-                # Publish both a ToolCallError and a user-facing ReportEvent for path security errors
-                self._publish_tool_call_error(
-                    tool_name, request_id, str(sec_err), arguments
-                )
-                if self._event_bus:
-                    from janito.report_events import (
-                        ReportEvent,
-                        ReportSubtype,
-                        ReportAction,
+            # Only validate paths for dictionary-style arguments
+            if isinstance(arguments, dict):
+                try:
+                    validate_paths_in_arguments(arguments, workdir, schema=schema)
+                except PathSecurityError as sec_err:
+                    # Publish both a ToolCallError and a user-facing ReportEvent for path security errors
+                    self._publish_tool_call_error(
+                        tool_name, request_id, str(sec_err), arguments
                     )
+                    if self._event_bus:
+                        from janito.report_events import (
+                            ReportEvent,
+                            ReportSubtype,
+                            ReportAction,
+                        )
 
-                    self._event_bus.publish(
-                        ReportEvent(
-                            subtype=ReportSubtype.ERROR,
-                            message=f"[SECURITY] Path access denied: {sec_err}",
-                            action=ReportAction.EXECUTE,
-                            tool=tool_name,
-                            context={"arguments": arguments, "request_id": request_id},
+                        self._event_bus.publish(
+                            ReportEvent(
+                                subtype=ReportSubtype.ERROR,
+                                message=f"[SECURITY] Path access denied: {sec_err}",
+                                action=ReportAction.EXECUTE,
+                                tool=tool_name,
+                                context={"arguments": arguments, "request_id": request_id},
+                            )
                         )
-                    )
-                return f"Security error: {sec_err}"
+                    return f"Security error: {sec_err}"
         # --- END SECURITY ---
 
         self._publish_tool_call_started(tool_name, request_id, arguments)
@@ -224,7 +232,18 @@ class ToolsAdapterBase:
             f"[tools-adapter] Executing tool: {tool_name} with arguments: {arguments}"
         )
         try:
-            result = self.execute(tool, **(arguments or {}), **kwargs)
+            # Normalize arguments to ensure proper type handling
+            normalized_args = self._normalize_arguments(arguments, tool, func)
+            
+            if isinstance(normalized_args, (list, tuple)):
+                # Positional arguments supplied as an array → expand as *args
+                result = self.execute(tool, *normalized_args, **kwargs)
+            elif isinstance(normalized_args, dict) or normalized_args is None:
+                # Keyword-style arguments (the default) – pass as **kwargs
+                result = self.execute(tool, **(normalized_args or {}), **kwargs)
+            else:
+                # Single positional argument (scalar/str/int/…)
+                result = self.execute(tool, normalized_args, **kwargs)
         except Exception as e:
             self._handle_execution_error(tool_name, request_id, e, arguments)
         self._print_verbose(
@@ -281,6 +300,65 @@ class ToolsAdapterBase:
         if self.verbose_tools:
             print(message)
 
+    def _normalize_arguments(self, arguments, tool, func):
+        """
+        Normalize arguments to ensure proper type handling at the adapter level.
+        
+        This handles cases where:
+        1. String is passed instead of list for array parameters
+        2. JSON string parsing issues
+        3. Other type mismatches that can be automatically resolved
+        """
+        import inspect
+        import json
+        
+        # If arguments is already a dict or None, return as-is
+        if isinstance(arguments, dict) or arguments is None:
+            return arguments
+            
+        # If arguments is a list/tuple, return as-is (positional args)
+        if isinstance(arguments, (list, tuple)):
+            return arguments
+            
+        # Handle string arguments
+        if isinstance(arguments, str):
+            # Try to parse as JSON if it looks like JSON
+            stripped = arguments.strip()
+            if (stripped.startswith('{') and stripped.endswith('}')) or \
+               (stripped.startswith('[') and stripped.endswith(']')):
+                try:
+                    parsed = json.loads(arguments)
+                    return parsed
+                except json.JSONDecodeError:
+                    # If it looks like JSON but failed, try to handle common issues
+                    pass
+            
+            # Check if the function expects a list parameter
+            try:
+                sig = inspect.signature(func)
+                params = list(sig.parameters.values())
+                
+                # Skip 'self' parameter for methods
+                if len(params) > 0 and params[0].name == 'self':
+                    params = params[1:]
+                
+                # If there's exactly one parameter that expects a list, wrap string in list
+                if len(params) == 1:
+                    param = params[0]
+                    annotation = param.annotation
+                    
+                    # Check if annotation is list[str] or similar
+                    if hasattr(annotation, '__origin__') and annotation.__origin__ is list:
+                        return [arguments]
+                    elif str(annotation).startswith('list[') or str(annotation) == 'list':
+                        return [arguments]
+                        
+            except (ValueError, TypeError):
+                pass
+                
+        # Return original arguments for other cases
+        return arguments
+
     def execute_function_call_message_part(self, function_call_message_part):
         """
         Execute a FunctionCallMessagePart by extracting the tool name and arguments and dispatching to execute_by_name.
@@ -298,9 +376,23 @@ class ToolsAdapterBase:
         # Parse arguments if they are a JSON string
         if isinstance(arguments, str):
             try:
+                # Try to parse as JSON first
                 arguments = json.loads(arguments)
-            except Exception:
-                pass  # Leave as string if not JSON
+            except json.JSONDecodeError:
+                # Handle single quotes in JSON strings
+                try:
+                    # Replace single quotes with double quotes for JSON compatibility
+                    fixed_json = arguments.replace("'", '"')
+                    arguments = json.loads(fixed_json)
+                except (json.JSONDecodeError, ValueError):
+                    # If it's a string that looks like it might be a single path parameter,
+                    # try to handle it gracefully
+                    if arguments.startswith("{") and arguments.endswith("}"):
+                        # Looks like JSON but failed to parse - this is likely an error
+                        pass
+                    else:
+                        # Single string argument - let the normalization handle it
+                        pass
         if self.verbose_tools:
             print(
                 f"[tools-adapter] Executing FunctionCallMessagePart: tool={tool_name}, arguments={arguments}, tool_call_id={tool_call_id}"

{janito-2.17.0 → janito-2.18.0}/janito.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.17.0
+Version: 2.18.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-2.17.0 → janito-2.18.0}/janito.egg-info/SOURCES.txt

@@ -30,10 +30,10 @@ docs/driver-flow.md
 docs/driver-request-cancellation.md
 docs/drivers.md
 docs/event-bus.md
-docs/index.md
 docs/llm-drivers-required-config.md
 docs/llm-drivers.md
 docs/moonshotai-setup.md
+docs/openai-setup.md
 docs/security.md
 docs/supported-providers-models.md
 docs/tools-index.md

{janito-2.17.0 → janito-2.18.0}/mkdocs.yml

@@ -35,9 +35,11 @@ nav:
       - API Reference: reference/api.md
   - Supported Providers & Models:
       - Overview: supported-providers-models.md
+      - OpenAI Setup: openai-setup.md
       - DeepSeek Setup: deepseek-setup.md
       - MoonshotAI Setup: moonshotai-setup.md
       - Z.ai Setup: z-ai-setup.md
+      - Cerebras Setup: cerebras-setup.md
   - Concepts:
       - Overview: concepts/index.md
       - What Is a Language Model Client?: concepts/language-model-clients.md

{janito-2.17.0 → janito-2.18.0}/tests/adapters/local/test_read_files.py

@@ -16,7 +16,7 @@ def test_read_files_tool(tmp_path, read_files_tool):
     file2.write_text("Second file contents.\n")
     missing_file = tmp_path / "missing.txt"
 
-    result = read_files_tool.run([str(file1), str(file2), str(missing_file)])
+    result = read_files_tool.run(paths=[str(file1), str(file2), str(missing_file)])
 
     assert "Hello from file 1!" in result
     assert "Second file contents." in result

janito-2.17.0/docs/index.md

@@ -1,26 +0,0 @@
-<p align="center">
-  <img src="imgs/happy-programmer.svg" alt="Janito Logo" width="180"/>
-</p>
-
-Janito is a lightweight language model client focused on software development activities, enabling automation of programming and project tasks through natural language using LLMs.
-
-## ✨ Key Features
-
--  ⚡ Automate code review, refactoring, and documentation
--  💬 Interactive pair programming chat mode
--  🖥️ Use via command-line with an optional web interface for complex manual edits
--  🔌 Easily extend with custom tools and plugins
--  🛡️ Robust configuration and quality checks
--  👨‍💻 Designed for developers, by developers
-
-
-- - -
-
-## 📚 Learn More
-
-- [What Is a Language Model Client?](concepts/language-model-clients.md) — Thin vs. Thick Clients explained
-- [Configuring Janito for DeepSeek](deepseek-setup.md) — How to set up and use DeepSeek models
-- [Configuring Janito for MoonshotAI](moonshotai-setup.md) — How to set up and use MoonshotAI models
-- [Configuring Janito for Z.ai](z-ai-setup.md) — How to set up and use Z.ai models
-- **Concepts & Terminology:** See the [concepts](concepts/index.md) section for more foundational explanations.
-