agentic-python-coder 3.1.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

agentic_python_coder/__init__.py

@@ -1,6 +1,11 @@
 """Python Coding Agent - A minimal coding assistant using direct OpenAI API and OpenRouter."""
 
-__version__ = "3.0.0"
+from importlib.metadata import PackageNotFoundError, version as _package_version
+
+try:
+    __version__ = _package_version("agentic-python-coder")
+except PackageNotFoundError:  # running from source without installation
+    __version__ = "0.0.0+unknown"
 
 # High-level API (recommended for most users)
 from agentic_python_coder.runner import solve_task

agentic_python_coder/agent.py

@@ -50,6 +50,7 @@ def create_coding_agent(
     api_key: Optional[str] = None,
     todo: bool = False,
     verbose: bool = False,
+    llm_config: Optional[LLMConfig] = None,
 ) -> CodingAgent:
     """Create a ReAct agent for Python coding tasks.
 
@@ -65,6 +66,8 @@ def create_coding_agent(
         api_key: Optional API key override
         todo: If True, includes todo_write tool for task tracking
         verbose: If True, print progress info (default False for library use)
+        llm_config: Optional pre-built LLMConfig (any OpenAI-compatible
+            client); takes precedence over model/api_key
 
     Returns:
         Configured CodingAgent
@@ -77,17 +80,19 @@ def create_coding_agent(
         set_task_basename(task_basename)
 
     # Store packages for kernel initialization (clear if None to avoid state leaks)
+    # JSON-encoded: a comma join would corrupt specs like "pkg[extra1,extra2]"
     if with_packages is not None:
-        os.environ["CODER_WITH_PACKAGES"] = ",".join(with_packages)
+        os.environ["CODER_WITH_PACKAGES"] = json.dumps(with_packages)
     else:
         os.environ.pop("CODER_WITH_PACKAGES", None)
 
-    # Get LLM config
-    llm_config = get_openrouter_llm(
-        model=model or DEFAULT_MODEL,
-        api_key=api_key,
-        verbose=verbose,
-    )
+    # Get LLM config (a pre-built one takes precedence)
+    if llm_config is None:
+        llm_config = get_openrouter_llm(
+            model=model or DEFAULT_MODEL,
+            api_key=api_key,
+            verbose=verbose,
+        )
 
     # Create tool registry
     tools = create_tool_registry(todo=todo)
@@ -199,8 +204,9 @@ def run_agent(
     Returns:
         Tuple of (List of new messages from this call, Statistics dictionary)
     """
-    # Set working directory at execution time (not creation time)
-    # This prevents race conditions when multiple agents are created
+    # The working directory is a process-wide singleton; set it at execution
+    # time so it always matches the agent currently running (concurrent
+    # run_agent calls in one process are not supported)
     working_dir.set(agent.working_directory)
 
     limit = step_limit if step_limit is not None else DEFAULT_STEP_LIMIT
@@ -228,7 +234,7 @@ def run_agent(
     openai_tools = agent.tools.get_openai_tools()
 
     # ReAct loop
-    for step_num in range(limit):
+    for _ in range(limit):
         # Build request kwargs
         request_kwargs: dict[str, Any] = {
             "model": agent.llm_config.model,
@@ -243,13 +249,17 @@ def run_agent(
         # Call API
         response = agent.llm_config.client.chat.completions.create(**request_kwargs)
 
-        # Track tokens
+        # Track tokens (some providers return usage objects with None fields)
         if response.usage:
-            stats["token_consumption"]["input_tokens"] += response.usage.prompt_tokens
+            stats["token_consumption"]["input_tokens"] += (
+                response.usage.prompt_tokens or 0
+            )
             stats["token_consumption"]["output_tokens"] += (
-                response.usage.completion_tokens
+                response.usage.completion_tokens or 0
+            )
+            stats["token_consumption"]["total_tokens"] += (
+                response.usage.total_tokens or 0
             )
-            stats["token_consumption"]["total_tokens"] += response.usage.total_tokens
 
         if not response.choices:
             break
@@ -324,6 +334,29 @@ def run_agent(
                     }
                 )
 
+        elif response.choices[0].finish_reason == "length":
+            # Response cut off at max_tokens with no tool call — don't accept
+            # the truncated text as a final answer; ask the model to continue
+            agent.messages.append(
+                {
+                    "role": "assistant",
+                    "content": assistant_message.content or "",
+                }
+            )
+            agent.messages.append(
+                {
+                    "role": "user",
+                    "content": (
+                        "Your previous response was truncated at the max_tokens "
+                        "limit. Continue, and be more concise."
+                    ),
+                }
+            )
+            if not quiet:
+                print(
+                    "Warning: response truncated at max_tokens; asking model to continue"
+                )
+
         else:
             # No tool calls — final answer
             agent.messages.append(
@@ -333,6 +366,11 @@ def run_agent(
                 }
             )
             break
+    else:
+        # Loop exhausted without a final answer
+        stats["step_limit_reached"] = True
+        if not quiet:
+            print(f"Warning: step limit ({limit}) reached without a final response")
 
     stats["execution_time_seconds"] = time.time() - start_time
 

agentic_python_coder/cli.py

@@ -260,6 +260,9 @@ def validate_model(model):
             print(f"  - {m}")
         print("\nOr provide a path to a custom model JSON file.")
         sys.exit(1)
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
 
 
 def load_project_prompt(project_path: str) -> Optional[str]:
@@ -290,12 +293,19 @@ def load_project_prompt(project_path: str) -> Optional[str]:
 
 
 def run_interactive(
-    working_dir: Path, model: str, project_prompt: str, api_key: str, todo: bool
+    working_dir: Path,
+    model: str,
+    project_prompt: str,
+    api_key: str,
+    todo: bool,
+    with_packages=None,
 ):
     """Run the agent in interactive mode."""
     print(f"\nInteractive mode - working in: {working_dir}")
     if project_prompt:
         print("Project configuration loaded")
+    if with_packages:
+        print(f"Dynamic packages: {', '.join(with_packages)}")
     print("Type 'exit' or 'quit' to stop.\n")
 
     # Load system prompt
@@ -307,12 +317,12 @@ def run_interactive(
         system_prompt=system_prompt,
         model=model,
         project_prompt=project_prompt,
+        with_packages=with_packages,
         api_key=api_key,
         todo=todo,
         verbose=True,
     )
 
-    thread_id = "interactive"
     all_messages = []
     cumulative_stats = {
         "tool_usage": {},
@@ -333,7 +343,7 @@ def run_interactive(
                     continue
 
                 print("\nAgent working...\n")
-                messages, stats = run_agent(agent, user_input, thread_id, quiet=False)
+                messages, stats = run_agent(agent, user_input, quiet=False)
                 all_messages.extend(messages)
 
                 # Update cumulative stats
@@ -440,7 +450,12 @@ def main():
     try:
         if args.interactive:
             run_interactive(
-                working_dir, args.model, project_prompt, args.api_key, args.todo
+                working_dir,
+                args.model,
+                project_prompt,
+                args.api_key,
+                args.todo,
+                with_packages=args.with_packages,
             )
         else:
             # Use solve_task for the main flow

agentic_python_coder/examples/clingo/clingo.md

@@ -29,9 +29,10 @@ Before completing your solution, verify:
 ☐ 2. **Model solves correctly** - At least one answer set is found (or UNSAT handled)
 ☐ 3. **Optimization applied** - If problem asks for optimal, use #minimize/#maximize
 ☐ 4. **Solution extracted** - Answer set atoms properly extracted and formatted
+☐ 4b. **No Model escapes on_model** - All solution data extracted to plain Python objects inside the callback (touching a Model after solve() returns segfaults)
 ☐ 5. **Output format correct** - JSON output with appropriate structure
 ☐ 6. **Predicates meaningful** - Clear names that reflect the problem domain
-☐ 7. **Constraints verified** - All problem constraints are encoded
+☐ 7. **Constraints verified independently** - All problem constraints are encoded AND re-checked by a plain-Python verify() whose expectations are re-derived from the problem text, not from your encoding's own interpretation
 ☐ 8. **File written** - Create `solution.py` with complete working code
 
 ## Section 2: Critical Rules of Engagement
@@ -474,6 +475,38 @@ def extract_solution(model):
     return solution
 ```
 
+### CRITICAL: The Model Object Is Only Valid Inside on_model (Segfault Risk)
+
+The `clingo.Model` object passed to your `on_model` callback is only valid DURING
+that callback. After `ctl.solve()` returns, clingo frees the underlying model —
+touching it later is a use-after-free that crashes the Python process with a
+segmentation fault (exit code 139) and NO Python traceback.
+
+Extract everything you need into plain Python objects (ints, strings, lists, dicts)
+INSIDE the callback. Never store the Model object itself for later use.
+
+```python
+# WRONG - segfaults after solve() returns:
+saved = None
+def on_model(m):
+    global saved
+    saved = m                        # Model outlives the callback
+ctl.solve(on_model=on_model)
+atoms = saved.symbols(atoms=True)    # use-after-free -> SIGSEGV, no traceback
+
+# CORRECT - extract inside the callback:
+result = []
+def on_model(m):
+    for a in m.symbols(atoms=True):
+        if a.match("assigned", 2):
+            result.append((str(a.arguments[0]), str(a.arguments[1])))
+ctl.solve(on_model=on_model)
+# work with the plain tuples in result
+```
+
+This also applies to verification: snapshot the atoms into plain Python inside
+`on_model`, then run your checks on the snapshot after solving.
+
 ## Section 4: Problem-Solving Pattern Library
 
 ### 4.1 Modeling State and Change (NEW - CRITICAL)
@@ -964,6 +997,36 @@ possible_col(C) :- col(C).
 4. **Let solver determine gaps**: Don't over-constrain non-run cells
 5. **Different is adjacent**: Cells of different colors/states CAN touch
 
+### 4.11 "Reachable Only After" / Ordered Reachability Constraints
+
+When a problem requires that some target element become reachable only after all
+other elements (or only after specific ones) under an evolving reachability process,
+do NOT model it as an existential ordering — guessing a permutation with the target
+pinned last only proves that SOME order exists, which is weaker than what such
+problems ask. The intended reading is almost always about the actual reachability
+process: everything reachable gets reached as soon as it is reachable.
+
+Model the process directly with a time-indexed fixpoint and constrain first-reach
+times:
+
+```asp
+step(0..max_step).
+reached(S, 0) :- start(S).
+reached(Y, T+1) :- edge(X, Y), reached(X, T), step(T+1), unlocked(X, Y, T).
+reached(X, T+1) :- reached(X, T), step(T+1).                    % persistence
+first_reached(X, 0) :- reached(X, 0).
+first_reached(X, T) :- reached(X, T), not reached(X, T-1), T > 0, step(T).
+
+% target must not become reachable before (or together with) any other element:
+:- first_reached(target, Tg), first_reached(X, Tx), X != target, Tx >= Tg.
+```
+
+Adapt `unlocked/3` to whatever gates progression (collected items, satisfied
+prerequisites, ...). Verify with a plain-Python simulation of the same process:
+repeatedly add everything currently reachable, one step at a time, and check the
+required ordering of first-reach steps against the problem text — do not reuse
+your encoding's ordering predicates in the verifier.
+
 ## Section 5: Debugging & Advanced Techniques
 
 ### 5.1 Efficient Generation: Constrain Choices Early (Anti-Pattern: Generate-and-Filter)

agentic_python_coder/examples/cpmpy/cpmpy.md

@@ -31,7 +31,7 @@ else:
 - `AllDifferent(vars)` - all different values
 - `sum(vars) == total` - sum constraint
 - `Circuit(x)` - variables x form a Hamiltonian circuit (for routing/tour problems)
-- `InDomain(var, [values])` - restrict variable to a set of values (import from cpmpy)
+- `InDomain(var, [values])` - restrict variable to a set of values. **Must be explicitly imported**: `from cpmpy import InDomain`
 - Logical: `&`, `|`, `~` on constraints; `(cond).implies(other)` on constraints only
 - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=` between variables and expressions
 - Element: `vars[idx]` where idx is a decision variable (direct indexing works)
@@ -54,4 +54,47 @@ else:
   model.maximize(profit)
   ```
 
-That's it. Read the problem carefully, model it declaratively, and let CPMpy find the optimal solution.
+## Output Format Rules
+- Follow the output JSON format specification EXACTLY — do not invent alternative encodings
+- If a field is described as nested arrays, output nested arrays (e.g., `[[1,2],[3,4]]`), never compress to single integers
+- If the narrative text conflicts with the explicit "Output format" block, the Output format block wins
+- If the narrative mentions optional variants or extensions of the problem ("one extension is...", "another version..."), solve the base problem as specified by the input data and the Output format block — do not output an extended variant unless the output spec explicitly requires it
+- Derive every output array's dimensions from parameters stated in the problem and from the axis names in the format spec: `result[a][b]` means outer axis `a` and inner axis `b` — never swap axes or substitute a different quantity
+- Check array dimensions and value ranges match the spec before saving
+
+## Verification Requirement (MANDATORY)
+
+CPMpy models can easily contain subtle logic bugs. Before saving, you MUST:
+
+1. **Solve and extract** the solution values
+2. **Write a `verify()` function** that checks every constraint from the problem statement using plain Python loops and asserts — independent of your CPMpy model:
+   ```python
+   def verify(result):
+       # Check array shapes — sizes re-derived from the problem text,
+       # NOT from variables your model introduced
+       assert len(result["schedule"]) == n_weeks
+       # Check each constraint with plain Python
+       for w in range(n_weeks):
+           teams_this_week = [result["schedule"][w][p] for p in range(n_periods)]
+           assert len(set(teams_this_week)) == len(teams_this_week), "Duplicate team in week"
+       # ... check ALL constraints from the problem statement
+       print("All checks passed")
+   ```
+
+   The verifier must be derived from the problem text alone: re-read the problem
+   statement and re-derive every expected dimension, entry encoding, and constraint
+   from its own parameters. Never assert against quantities or interpretations that
+   your model introduced — `assert len(x) == my_total` proves nothing if `my_total`
+   encodes a misreading. If your model and your verifier share an assumption, a
+   wrong assumption passes silently.
+3. **Execute the verification** via python_exec and confirm it passes
+4. **For optimization**: verify optimality by re-solving with a stricter bound:
+   ```python
+   model2 = Model(model.constraints)
+   model2 += objective < best_value  # or > for maximize
+   assert not model2.solve(), "Solution is not optimal"
+   ```
+
+Do NOT call save_code until verification passes. If it fails, fix the model and re-verify.
+
+That's it. Read the problem carefully, model it declaratively, verify independently, and let CPMpy find the optimal solution.

agentic_python_coder/kernel.py

@@ -250,6 +250,7 @@ except ImportError:
 
         # Wait for and collect messages with hard deadline
         deadline = time.monotonic() + deadline_timeout
+        completed = False
 
         while time.monotonic() < deadline:
             try:
@@ -274,10 +275,26 @@ except ImportError:
                     if content.get("traceback"):
                         output["error"] += "\n" + "\n".join(content["traceback"])
                 elif msg_type == "status" and content["execution_state"] == "idle":
+                    completed = True
                     break  # Only exit on idle status
             except Empty:
                 continue  # Keep waiting, don't break
 
+        if not completed:
+            # Deadline hit while the kernel was still running: report a
+            # timeout instead of silently returning partial output as success,
+            # and interrupt so the kernel doesn't block the next execution
+            if output["error"] is None:
+                output["error"] = (
+                    f"Execution timed out after {deadline_timeout} seconds"
+                    " (partial output returned)"
+                )
+            try:
+                self.km.interrupt_kernel()
+                time.sleep(0.5)  # grace period so the next execute isn't aborted
+            except Exception:
+                pass  # Best effort
+
         return output
 
     def execute(self, code: str, deadline_timeout: int = 60) -> Dict[str, str]:

agentic_python_coder/llm.py

@@ -133,6 +133,10 @@ def get_openrouter_llm(
 ) -> LLMConfig:
     """Create a fully configured LLMConfig for OpenRouter.
 
+    The model JSON may override the endpoint with "base_url" (any
+    OpenAI-compatible server) and "api_key_env" (name of the environment
+    variable holding the key for that endpoint).
+
     Args:
         model: Model name (e.g., "sonnet45") or path to JSON file
         api_key: Optional API key
@@ -158,17 +162,27 @@ def get_openrouter_llm(
 
     # Get API key
     if not api_key:
-        api_key = get_api_key()
+        if "api_key_env" in config:
+            api_key = os.getenv(config["api_key_env"])
+            if not api_key:
+                raise ValueError(
+                    f"Environment variable '{config['api_key_env']}' not set "
+                    f"(required by model config '{model}')"
+                )
+        else:
+            api_key = get_api_key()
 
     # Build client kwargs
     client_kwargs: dict[str, Any] = {
         "api_key": api_key,
-        "base_url": "https://openrouter.ai/api/v1",
-        "default_headers": {
+        "base_url": config.get("base_url", "https://openrouter.ai/api/v1"),
+    }
+    if "base_url" not in config:
+        # OpenRouter attribution headers; skip for custom endpoints
+        client_kwargs["default_headers"] = {
             "HTTP-Referer": "https://github.com/szeider/agentic-python-coder",
             "X-Title": "Agentic Python Coder",
-        },
-    }
+        }
 
     # Add request_timeout as client timeout
     if "request_timeout" in config:
@@ -201,4 +215,8 @@ def get_openrouter_llm(
     if "provider" in config:
         api_params.setdefault("extra_body", {})["provider"] = config["provider"]
 
+    # Reasoning/thinking tokens (e.g. Gemini 3 Flash thinking levels)
+    if "reasoning" in config:
+        api_params.setdefault("extra_body", {})["reasoning"] = config["reasoning"]
+
     return LLMConfig(client=client, model=model_id, api_params=api_params)

agentic_python_coder/mcp_server.py

@@ -39,16 +39,15 @@ _session_lock = asyncio.Lock()
 
 
 def truncate_output(result: dict) -> dict:
-    """Truncate stdout/stderr if too large and add success flag."""
+    """Truncate oversized text fields and add success flag."""
     # Add success flag based on error field
     result["success"] = result.get("error") is None
 
     max_kb = MAX_OUTPUT // 1024
-    for key in ["stdout", "stderr"]:
-        if key in result and result[key] and len(result[key]) > MAX_OUTPUT:
-            result[key] = (
-                result[key][:MAX_OUTPUT] + f"\n[{key} truncated at {max_kb}KB]"
-            )
+    for key in ["stdout", "stderr", "result", "error"]:
+        value = result.get(key)
+        if isinstance(value, str) and len(value) > MAX_OUTPUT:
+            result[key] = value[:MAX_OUTPUT] + f"\n[{key} truncated at {max_kb}KB]"
     return result
 
 

agentic_python_coder/models/deepseek31.json

@@ -2,6 +2,5 @@
   "path": "deepseek/deepseek-chat-v3.1",
   "temperature": 0.2,
   "max_tokens": 8192,
-  "streaming": true,
   "top_p": 1.0
 }

agentic_python_coder/models/gemini25.json

@@ -2,7 +2,6 @@
   "path": "google/gemini-2.5-pro",
   "temperature": 0.3,
   "max_tokens": 2048,
-  "streaming": true,
   "top_p": 0.9,
   "request_timeout": 60
 }

agentic_python_coder/models/gemini31.json

@@ -0,0 +1,6 @@
+{
+  "path": "google/gemini-3.1-pro-preview",
+  "temperature": 0.0,
+  "max_tokens": 16384,
+  "request_timeout": 120
+}

agentic_python_coder/models/gemini3pro.json

@@ -2,7 +2,6 @@
   "path": "google/gemini-3-pro-preview",
   "temperature": 0.3,
   "max_tokens": 16384,
-  "streaming": true,
   "top_p": 0.9,
   "request_timeout": 120
 }

agentic_python_coder/models/gpt52.json

@@ -1,6 +1,5 @@
 {
   "path": "openai/gpt-5.2",
   "max_tokens": 16384,
-  "streaming": true,
   "no_sampling_params": true
 }

agentic_python_coder/models/gpt56sol.json

@@ -0,0 +1,5 @@
+{
+  "path": "openai/gpt-5.6-sol",
+  "max_tokens": 16384,
+  "no_sampling_params": true
+}

agentic_python_coder/models/gpt56terra.json

@@ -0,0 +1,5 @@
+{
+  "path": "openai/gpt-5.6-terra",
+  "max_tokens": 16384,
+  "no_sampling_params": true
+}

agentic_python_coder/models/grok41.json

@@ -2,6 +2,5 @@
   "path": "x-ai/grok-4.1-fast",
   "temperature": 0.15,
   "max_tokens": 2000,
-  "streaming": true,
   "top_p": 0.9
 }

agentic_python_coder/models/opus45.json

@@ -1,6 +1,5 @@
 {
   "path": "anthropic/claude-opus-4.5",
   "temperature": 0.0,
-  "max_tokens": 16384,
-  "streaming": true
+  "max_tokens": 16384
 }

agentic_python_coder/models/opus48.json

@@ -0,0 +1,5 @@
+{
+  "path": "anthropic/claude-opus-4.8",
+  "temperature": 0.0,
+  "max_tokens": 16384
+}

agentic_python_coder/models/qwen3.json

@@ -2,6 +2,5 @@
   "path": "qwen/qwen3-coder",
   "temperature": 0.15,
   "max_tokens": 2048,
-  "streaming": true,
   "top_p": 0.9
 }

agentic_python_coder/models/sonnet45.json

@@ -1,6 +1,5 @@
 {
   "path": "anthropic/claude-sonnet-4.5",
   "temperature": 0.0,
-  "max_tokens": 16384,
-  "streaming": true
+  "max_tokens": 16384
 }

agentic_python_coder/models/sonnet46.json

@@ -0,0 +1,5 @@
+{
+  "path": "anthropic/claude-sonnet-4.6",
+  "temperature": 0.0,
+  "max_tokens": 16384
+}

agentic_python_coder/models/sonnet5.json

@@ -0,0 +1,5 @@
+{
+  "path": "anthropic/claude-sonnet-5",
+  "temperature": 0.0,
+  "max_tokens": 32768
+}

agentic_python_coder/project_md.py

@@ -53,8 +53,12 @@ def check_packages_available(packages: List[str]) -> List[str]:
     unavailable = []
 
     for package in packages:
-        # Try to find the package
-        spec = importlib.util.find_spec(package)
+        # Try to find the package; find_spec raises for dotted names with a
+        # missing parent or otherwise invalid names — treat those as unavailable
+        try:
+            spec = importlib.util.find_spec(package)
+        except (ImportError, ValueError):
+            spec = None
         if spec is None:
             unavailable.append(package)
 

agentic_python_coder/runner.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Optional, List, Any, Dict
 
 from agentic_python_coder.agent import create_coding_agent, run_agent
+from agentic_python_coder.llm import LLMConfig
 
 
 def get_system_prompt_path(todo: bool = False) -> Path:
@@ -233,7 +234,9 @@ def save_conversation_log(
             json.dumps(
                 {
                     "event": "complete",
-                    "status": "success",
+                    "status": "step_limit_reached"
+                    if stats and stats.get("step_limit_reached")
+                    else "success",
                 }
             )
             + "\n"
@@ -256,6 +259,7 @@ def solve_task(
     save_log: bool = True,
     task_basename: Optional[str] = None,
     step_limit: Optional[int] = None,
+    llm_config: Optional[LLMConfig] = None,
 ) -> tuple[List[Any], Dict[str, Any], Optional[Path]]:
     """Run a complete coding task end-to-end.
 
@@ -275,6 +279,8 @@ def solve_task(
         save_log: Save conversation log to file (default: True)
         task_basename: Base name for output files
         step_limit: Maximum agent steps before stopping (default: 200)
+        llm_config: Optional pre-built LLMConfig (any OpenAI-compatible
+            client); takes precedence over model/api_key
 
     Returns:
         Tuple of (messages, stats, log_path)
@@ -313,6 +319,7 @@ def solve_task(
         api_key=api_key,
         todo=todo,
         verbose=not quiet,
+        llm_config=llm_config,
     )
 
     # Run agent

agentic_python_coder/tools.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import List, Dict, Any, Callable
 
-from .kernel import get_kernel, format_output
+from .kernel import get_kernel, format_output, shutdown_kernel
 
 
 @dataclass
@@ -50,10 +50,6 @@ class ToolRegistry:
         """Get a tool by name."""
         return self._tools.get(name)
 
-    def has(self, name: str) -> bool:
-        """Check if a tool is registered."""
-        return name in self._tools
-
     def get_openai_tools(self) -> list[dict[str, Any]]:
         """Get all tools in OpenAI format."""
         return [tool.to_openai_tool() for tool in self._tools.values()]
@@ -171,7 +167,14 @@ def python_exec(code: str) -> str:
     with_packages = None
     if "CODER_WITH_PACKAGES" in os.environ:
         packages_str = os.environ["CODER_WITH_PACKAGES"]
-        with_packages = packages_str.split(",") if packages_str else []
+        if not packages_str:
+            with_packages = []
+        else:
+            try:
+                with_packages = json.loads(packages_str)
+            except json.JSONDecodeError:
+                # Legacy comma-joined format
+                with_packages = packages_str.split(",")
 
     try:
         kernel = get_kernel(cwd=str(working_dir.get()), with_packages=with_packages)
@@ -214,6 +217,16 @@ def save_code(code: str) -> str:
         else:
             filename = "solution.py"
 
+        # Reject non-compiling code so the model gets feedback instead of a
+        # silently broken file (e.g. from a bad escape in the tool-call JSON)
+        try:
+            compile(code, filename, "exec")
+        except SyntaxError as e:
+            return error_response(
+                f"Code NOT saved — syntax error at line {e.lineno}: {e.msg}. "
+                "Fix the code and call save_code again."
+            )
+
         output_path = working_dir.get() / filename
         output_path.write_text(code)
 
@@ -223,10 +236,16 @@ def save_code(code: str) -> str:
 
 
 def reset_global_state():
-    """Reset all global state to avoid accumulation across runs."""
+    """Reset all global state to avoid accumulation across runs.
+
+    Also shuts down the default kernel so the next execution starts a fresh
+    one — otherwise a second agent in the same process would silently reuse
+    the previous agent's kernel (its cwd, packages, and variables).
+    """
     global _todos, _task_basename
     _todos = []
     _task_basename = None
+    shutdown_kernel()
 
 
 # Tool definitions with explicit JSON schemas
@@ -281,6 +300,8 @@ SAVE_CODE_TOOL = Tool(
         "2. Verified the output format matches the specification exactly (JSON keys, array shapes, value ranges)\n"
         "3. For constraint/logic problems: run an independent verification checking every constraint\n"
         "Do NOT save unverified code. If verification fails, fix the code and re-verify first.\n\n"
+        "The code is syntax-checked before saving; on a syntax error nothing is\n"
+        "written and an error is returned — fix the code and save again.\n\n"
         "Args:\n"
         "    code: The complete Python code\n\n"
         "Returns:\n"

{agentic_python_coder-3.1.0.dist-info → agentic_python_coder-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-python-coder
-Version: 3.1.0
+Version: 3.3.0
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0
@@ -14,21 +14,21 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.13
-Requires-Dist: ipykernel>=7.2.0
-Requires-Dist: jupyter-client>=8.8.0
-Requires-Dist: mcp>=1.26.0
-Requires-Dist: openai>=2.21.0
-Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: ipykernel>=7.3.0
+Requires-Dist: jupyter-client>=8.9.1
+Requires-Dist: mcp>=1.28.1
+Requires-Dist: openai>=2.45.0
+Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: rich>=14.3.2
+Requires-Dist: rich>=15.0.0
 Provides-Extra: dev
-Requires-Dist: mypy>=1.19.1; extra == 'dev'
-Requires-Dist: ruff>=0.14.14; extra == 'dev'
+Requires-Dist: mypy>=2.2.0; extra == 'dev'
+Requires-Dist: ruff>=0.15.21; extra == 'dev'
 Provides-Extra: test
-Requires-Dist: pytest-asyncio>=1.3.0; extra == 'test'
-Requires-Dist: pytest-cov>=7.0.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.4.0; extra == 'test'
+Requires-Dist: pytest-cov>=7.1.0; extra == 'test'
 Requires-Dist: pytest-watch>=4.2.0; extra == 'test'
-Requires-Dist: pytest>=9.0.2; extra == 'test'
+Requires-Dist: pytest>=9.1.1; extra == 'test'
 Description-Content-Type: text/markdown
 
 # Agentic Python Coder
@@ -147,19 +147,41 @@ coder -i
 ```bash
 # Built-in models (versioned names)
 coder --model sonnet45 "task"   # Claude Sonnet 4.5 (default)
+coder --model sonnet46 "task"   # Claude Sonnet 4.6
+coder --model sonnet5 "task"    # Claude Sonnet 5
 coder --model opus45 "task"     # Claude Opus 4.5
+coder --model opus48 "task"     # Claude Opus 4.8
 coder --model deepseek31 "task" # DeepSeek v3.1
 coder --model grok41 "task"     # X.AI Grok 4.1
 coder --model qwen3 "task"      # Qwen3 Coder
 coder --model gemini25 "task"     # Gemini Pro 2.5
 coder --model gemini3pro "task"    # Gemini 3 Pro Preview
+coder --model gemini31 "task"      # Gemini 3.1 Pro Preview
 coder --model gemini3flash "task"  # Gemini 3 Flash Preview (fast, low-cost)
 coder --model gpt52 "task"         # GPT-5.2
+coder --model gpt56sol "task"      # GPT-5.6 Sol
+coder --model gpt56terra "task"    # GPT-5.6 Terra
 
 # Custom model (JSON file)
 coder --model ./mymodel.json "task"
 ```
 
+A custom model JSON can also point at any OpenAI-compatible endpoint
+(OpenAI directly, a local Ollama/vLLM server, etc.) instead of OpenRouter:
+
+```json
+{
+  "path": "gpt-4o-mini",
+  "base_url": "https://api.openai.com/v1",
+  "api_key_env": "OPENAI_API_KEY",
+  "temperature": 0.0
+}
+```
+
+`base_url` overrides the OpenRouter endpoint; `api_key_env` names the
+environment variable holding the key for that endpoint (default:
+`OPENROUTER_API_KEY`).
+
 ### Project Templates
 
 Domain-specific templates improve results. Bundled examples are available on GitHub at [`coder/src/agentic_python_coder/examples/`](coder/src/agentic_python_coder/examples/). Use `--init` to copy them locally:
@@ -225,6 +247,7 @@ messages, stats, log_path = solve_task(
     save_log=True,                   # Save conversation log
     task_basename=None,              # Base name for output files
     step_limit=None,                 # Max agent steps (default: 200)
+    llm_config=None,                 # Pre-built LLMConfig (overrides model/api_key)
 )
 ```
 
@@ -253,6 +276,25 @@ messages2, stats2 = run_agent(agent, "Now plot column A", quiet=True)
 print(get_final_response(messages2))
 ```
 
+Instead of a model name, you can pass a pre-built `LLMConfig` wrapping any
+OpenAI-compatible client:
+
+```python
+from openai import OpenAI
+from agentic_python_coder import LLMConfig, create_coding_agent
+
+llm_config = LLMConfig(
+    client=OpenAI(api_key="...", base_url="https://api.openai.com/v1"),
+    model="gpt-4o-mini",
+    api_params={"temperature": 0.0},
+)
+
+agent = create_coding_agent(
+    working_directory="/tmp/workspace",
+    llm_config=llm_config,
+)
+```
+
 #### `get_openrouter_llm()` — LLM Access
 
 ```python

agentic_python_coder-3.3.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+agentic_python_coder/__init__.py,sha256=e6o-k__u5xNIiQAkZbHtbZC2-NwpeOdi4MdQtAqJBjE,2112
+agentic_python_coder/agent.py,sha256=gzDFf4n7J1JdWawYPzWQFVwcHZ2rsRHUzVZVcGYjQWo,14451
+agentic_python_coder/cli.py,sha256=HS9nlqsiWZAvg0Hc8ExoVT8eEcy2t3Bux6UGukERWqQ,14663
+agentic_python_coder/kernel.py,sha256=PQrKMi0_mKVeG1q2wXTu3-W2ZYKwYNjtPI_3A4m4Gvg,21284
+agentic_python_coder/llm.py,sha256=zjsk4-Kdx92hFSxywPGIkLv8zflWnE2cMEcpeXu6ttw,6998
+agentic_python_coder/mcp_server.py,sha256=2Z5O9n5QgZrgn3GdFljjF7Yq5e9tE1zNlAWBPyckrlI,18503
+agentic_python_coder/project_md.py,sha256=4xkQHlWb4cDPEkvegw1YwcfaTJ3aFbrl0CYcC_xxABY,3249
+agentic_python_coder/runner.py,sha256=Kbw1ceYJ4MVfUKgSIkiuBhMb8ZtbZuJwbBeTUsvPRts,13045
+agentic_python_coder/tools.py,sha256=tjhQbsF3n3bFIegnEOtE8czjzbtMSXy6B9gYeb-YAJ4,12088
+agentic_python_coder/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentic_python_coder/examples/clingo/README.md,sha256=SgWBqdJ2cHIfYWRV1YYqzfY0rth7mjCR5Act_hchcx0,2345
+agentic_python_coder/examples/clingo/clingo.md,sha256=n8JOtpOww4T494OgLI_at8Zoz5pl7lv3AGOKlCA-cVE,52959
+agentic_python_coder/examples/clingo/sample_tasks/bird_reasoning.md,sha256=OsOZDOzaj_wDEEhvq2raIK_P8VJY0Se6pgt3UJ8DY30,1660
+agentic_python_coder/examples/clingo/sample_tasks/diagnosis.md,sha256=s5Q9WoLvInKcwitgY2TCdqFt4xdnxfd5FcMNywfT7p8,1818
+agentic_python_coder/examples/clingo/sample_tasks/simple_coloring.md,sha256=T_44hh5nY-RSNw021DL-flEoLlfwyZMOheIf5-C0hE4,538
+agentic_python_coder/examples/clingo/sample_tasks/stable_marriage.md,sha256=mWNAHmMstUq0VIYkDzrgK4PuiS59n6gMU3lMJrQ02c4,679
+agentic_python_coder/examples/clingo/sample_tasks/sudoku_mini.md,sha256=rdEd3dkuh0V4sfosoXwEVe049T4QcOA4ZcgwdLQnC-M,475
+agentic_python_coder/examples/cpmpy/README.md,sha256=4XqG8kvdBON6WGw5TPrGpqqBspuH2nsQ3NkZl9FzAM0,1399
+agentic_python_coder/examples/cpmpy/cpmpy.md,sha256=O5WtJOoJl8i-MgzrFCbuCCGRrfo-zI8hZcCUkhzOqO0,4971
+agentic_python_coder/examples/cpmpy/sample_tasks/magic_square.md,sha256=lUsnYoiJy7i6tXmFFISkTB6OrFTRPBDoxkJv9mceY-o,1127
+agentic_python_coder/examples/cpmpy/sample_tasks/n_queens.md,sha256=WybTtZMlD28B1XAUf91IWqvrXIh5MTKWXHXnqfvpysM,848
+agentic_python_coder/examples/regex/README.md,sha256=3K8nK-nVFrjweusS0Zdjt3Oh-UIc0mhgUuxVKGfi3QU,1378
+agentic_python_coder/examples/regex/regex.md,sha256=3D64k-hoLiV_Io5LAjOXcdSrCNVAkKoqTzieOfXqM14,3126
+agentic_python_coder/examples/regex/sample_tasks/email_extraction.md,sha256=M5_CZ1Tf-o1HBCqTlWszGQSYQ2QCkOxiIA08tRfoDiE,785
+agentic_python_coder/examples/regex/sample_tasks/phone_validation.md,sha256=yoij3IlEDfWsNQ6UXkDUaNHPVbOb3pMcYO5v1pdLS-E,748
+agentic_python_coder/examples/regex/sample_tasks/url_parsing.md,sha256=C2E6ze-AeIXbzM-gB0aJ3_QSiaJB3c2MbMTNJXzuYhA,1683
+agentic_python_coder/models/deepseek31.json,sha256=42qWgfBn2ErZndbpp-4-JtqRna2xlwzkfCaYnKFEboQ,104
+agentic_python_coder/models/gemini25.json,sha256=I3nNMz2GwhFQLtHtZotV3hNUyWXq9ToMm96byM98LFA,123
+agentic_python_coder/models/gemini31.json,sha256=q8y8pPEZE1hsv2vV7c1KckPHKE7Gfbi51xQgwM62i-o,117
+agentic_python_coder/models/gemini3flash.json,sha256=S0AMVpzi3O5CQk68Q3Hi8iCHXMQQFnM4NbSh23x0qIM,91
+agentic_python_coder/models/gemini3pro.json,sha256=5yWdmtkKSpAvr8svGjAgSoXvCnu1SCoVnhdbx-1L4fQ,131
+agentic_python_coder/models/gpt52.json,sha256=oDYxC21iQTKC9uVbFRlAs-hCnu_4cEDFK3mmqPVIIes,84
+agentic_python_coder/models/gpt56sol.json,sha256=xFNDxSz0ZC2qtDldgZ3ms1ela1InmhL5x_-UZktR1K8,88
+agentic_python_coder/models/gpt56terra.json,sha256=NnVvnnF7EMK-pADCZsm1fJ8O8DLCT4obHc0x_00kcus,90
+agentic_python_coder/models/grok41.json,sha256=l76RtbnFiNNQEe_dFoxn0HNbjgTcOMk5MswYqhcw764,96
+agentic_python_coder/models/opus45.json,sha256=wbRqoIrn1CSlu0pRnpR2S-1j1zWGD_jza7udZNnU3wY,87
+agentic_python_coder/models/opus48.json,sha256=grMqaY0sCQnZeH4VxsPfwUIqlHpxNxTjmM47hHuyPkY,87
+agentic_python_coder/models/qwen3.json,sha256=TJuIx5EllPIc8QBnagINlhNVxkLlsSDWRZAsFMqP_lo,94
+agentic_python_coder/models/sonnet45.json,sha256=WeWezJxt4r7IugBMzRbnSIocmmcd6qc_756M4CHdEa8,89
+agentic_python_coder/models/sonnet46.json,sha256=Ops1FpBoyx9PBGRhIXG8u-YGBgIui9DqvYxIc2BkJFM,89
+agentic_python_coder/models/sonnet5.json,sha256=kf6DIkQlcGVZ40IzRv3GXFtNncZF_gKqQeGzZAxE_KM,87
+agentic_python_coder/prompts/system.md,sha256=hREDVAhJXwCBAgJ3AE9JD6j-JRHREUPlkRSvThOvM3A,3807
+agentic_python_coder/prompts/system_todo.md,sha256=TuNeeUNS9KqyF62Da6t2mlUCYhKsgzwGe5ic_vFPDqw,5054
+agentic_python_coder-3.3.0.dist-info/METADATA,sha256=ec4FIlQitVNa_5bMQhu2NPpJV-5VwDRQy1hzK_4b_G8,12872
+agentic_python_coder-3.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+agentic_python_coder-3.3.0.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
+agentic_python_coder-3.3.0.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
+agentic_python_coder-3.3.0.dist-info/RECORD,,

{agentic_python_coder-3.1.0.dist-info → agentic_python_coder-3.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any

agentic_python_coder-3.1.0.dist-info/RECORD

@@ -1,42 +0,0 @@
-agentic_python_coder/__init__.py,sha256=AE7tDIivH7H0BBwhrR9C64rY6pO1d6AWDQYGAvGjeuk,1881
-agentic_python_coder/agent.py,sha256=Z7I0zvh3XEouPgt9hvkSIKYuZyHfsTrsTEFiJjsK4hk,12821
-agentic_python_coder/cli.py,sha256=pjmKHwLmC41wJ4Z6tQPFNeS2VwC-HCvtXklmv__xOco,14349
-agentic_python_coder/kernel.py,sha256=Xjqsl-Rzb6JBqWMTE4JBsxNsy1eRVUL5FvtfT1OFLD4,20541
-agentic_python_coder/llm.py,sha256=8BxNK8FmECbcJhP5qeB8IxErbm1NKBZO4Z-bB5-JtaE,6157
-agentic_python_coder/mcp_server.py,sha256=U_YfjeUvaVJ4poCsIqkzOx70J190RYH2Ln_H5tDc6Zg,18508
-agentic_python_coder/project_md.py,sha256=c4A-rbsc3ryqUkCJLGOKBHH8QJL5kAqvTSsM0tDeD4Y,3041
-agentic_python_coder/runner.py,sha256=AtdtRusD5ThTlsdL2SDjYk73jD0fYRWkJ4vmpeIWBl4,12683
-agentic_python_coder/tools.py,sha256=Qo_VI5ABqrHOFb80JlwYbH_RJmgCNZagFsTv7RmJNNE,11127
-agentic_python_coder/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentic_python_coder/examples/clingo/README.md,sha256=SgWBqdJ2cHIfYWRV1YYqzfY0rth7mjCR5Act_hchcx0,2345
-agentic_python_coder/examples/clingo/clingo.md,sha256=VhIcECJwbmoV8T-GKok27Er_AvDpKj1qnzz4Zn7ddBI,49901
-agentic_python_coder/examples/clingo/sample_tasks/bird_reasoning.md,sha256=OsOZDOzaj_wDEEhvq2raIK_P8VJY0Se6pgt3UJ8DY30,1660
-agentic_python_coder/examples/clingo/sample_tasks/diagnosis.md,sha256=s5Q9WoLvInKcwitgY2TCdqFt4xdnxfd5FcMNywfT7p8,1818
-agentic_python_coder/examples/clingo/sample_tasks/simple_coloring.md,sha256=T_44hh5nY-RSNw021DL-flEoLlfwyZMOheIf5-C0hE4,538
-agentic_python_coder/examples/clingo/sample_tasks/stable_marriage.md,sha256=mWNAHmMstUq0VIYkDzrgK4PuiS59n6gMU3lMJrQ02c4,679
-agentic_python_coder/examples/clingo/sample_tasks/sudoku_mini.md,sha256=rdEd3dkuh0V4sfosoXwEVe049T4QcOA4ZcgwdLQnC-M,475
-agentic_python_coder/examples/cpmpy/README.md,sha256=4XqG8kvdBON6WGw5TPrGpqqBspuH2nsQ3NkZl9FzAM0,1399
-agentic_python_coder/examples/cpmpy/cpmpy.md,sha256=tQpZpM2CO1lG0r-_TGYi-fd9KrdyGr6kyqyeWjyPECs,2207
-agentic_python_coder/examples/cpmpy/sample_tasks/magic_square.md,sha256=lUsnYoiJy7i6tXmFFISkTB6OrFTRPBDoxkJv9mceY-o,1127
-agentic_python_coder/examples/cpmpy/sample_tasks/n_queens.md,sha256=WybTtZMlD28B1XAUf91IWqvrXIh5MTKWXHXnqfvpysM,848
-agentic_python_coder/examples/regex/README.md,sha256=3K8nK-nVFrjweusS0Zdjt3Oh-UIc0mhgUuxVKGfi3QU,1378
-agentic_python_coder/examples/regex/regex.md,sha256=3D64k-hoLiV_Io5LAjOXcdSrCNVAkKoqTzieOfXqM14,3126
-agentic_python_coder/examples/regex/sample_tasks/email_extraction.md,sha256=M5_CZ1Tf-o1HBCqTlWszGQSYQ2QCkOxiIA08tRfoDiE,785
-agentic_python_coder/examples/regex/sample_tasks/phone_validation.md,sha256=yoij3IlEDfWsNQ6UXkDUaNHPVbOb3pMcYO5v1pdLS-E,748
-agentic_python_coder/examples/regex/sample_tasks/url_parsing.md,sha256=C2E6ze-AeIXbzM-gB0aJ3_QSiaJB3c2MbMTNJXzuYhA,1683
-agentic_python_coder/models/deepseek31.json,sha256=m3h2-rieY23gTXj9AOFoWxnrYUfqNpDpyNpPW0SMqVE,125
-agentic_python_coder/models/gemini25.json,sha256=Z9qJrIUNel366A3hSdg3qQixTh-EU8lehXKebW-XEUY,144
-agentic_python_coder/models/gemini3flash.json,sha256=S0AMVpzi3O5CQk68Q3Hi8iCHXMQQFnM4NbSh23x0qIM,91
-agentic_python_coder/models/gemini3pro.json,sha256=ptozne-ZwpmuXzpt2x0ZApMIvb5VsWskqI36XscCsrg,152
-agentic_python_coder/models/gpt52.json,sha256=rGYoD83_yioSDJvO3o4FSFhi0B2yTaOpCgr_XpRaPWk,105
-agentic_python_coder/models/grok41.json,sha256=bUFtp2orkBmfiLH7mE8SaS0YEe2kJFF1Ex2jb03p9SA,117
-agentic_python_coder/models/opus45.json,sha256=ujBiZiA-6YNbQxd3xWlGT7YGtEtbWMC8e2TP0I8Gtho,108
-agentic_python_coder/models/qwen3.json,sha256=Lj39r787EcfUcKXfO52aplYurkpM9mG1qg71UkaqVfQ,115
-agentic_python_coder/models/sonnet45.json,sha256=SXDBHwSRMlqG77i4OhvNDlHL7fESnCoqmEplXm3gP4k,110
-agentic_python_coder/prompts/system.md,sha256=hREDVAhJXwCBAgJ3AE9JD6j-JRHREUPlkRSvThOvM3A,3807
-agentic_python_coder/prompts/system_todo.md,sha256=TuNeeUNS9KqyF62Da6t2mlUCYhKsgzwGe5ic_vFPDqw,5054
-agentic_python_coder-3.1.0.dist-info/METADATA,sha256=xnk9vllNKDqyvwZrIc2LH-g7d2O87wGzd5B2i6PAqps,11564
-agentic_python_coder-3.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-agentic_python_coder-3.1.0.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
-agentic_python_coder-3.1.0.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
-agentic_python_coder-3.1.0.dist-info/RECORD,,