pyagentkit 1.0.0__tar.gz → 1.1.0__tar.gz

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentkit
-Version: 1.0.0
+Version: 1.1.0
 Summary: Agent toolkit for Ollama
 Project-URL: Homepage, https://github.com/TarikEren/pyagentkit
 Project-URL: Issues, https://github.com/TarikEren/pyagentkit/issues
@@ -33,7 +33,8 @@ A Python library for building tool-calling agents on top of locally-hosted LLMs
 - **Dependency injection** — pass runtime dependencies (database connections, config, etc.) through `AgentDependencies` into tools without polluting tool signatures
 - **Retry logic** — configurable retry budgets separately for tool calls and for response validation failures
 - **Approval gates** — optionally require human confirmation before any tool is executed
-- **Lifecycle hooks** — callbacks for tool calls, retries, successes, and final responses
+- **Lifecycle hooks** — sync and async callbacks for tool calls, retries, successes, and final responses
+- **Validation hook** — supply `on_validate` to run custom response logic and trigger retries or abort
 - **Agent composition** — expose any agent as a tool that another agent can call via `.as_tool()`
 - **Token usage tracking** — cumulative `TokenUsage` object updated after every LLM call
 - **Message history** — persistent within a session, with optional trimming, save, and load
@@ -76,19 +77,21 @@ src/pyagentkit/
 Every agent responds in one of two JSON shapes, validated via Pydantic:
 
 ```json
-// Tool call
 {
   "response": {
     "type": "tool_call",
+    "message": "<why you're calling the tool>",
     "tool_call": { "name": "my_tool", "params": [{ "name": "x", "value": "42" }] }
-  },
-  "message": "Calling my_tool to get the result"
+  }
 }
+```
 
-// Final answer
+```json
 {
-  "response": { "type": "final" },
-  "message": "The answer is 42"
+  "response": {
+    "type": "final",
+    "message": "<your answer or result of your operation(s)>"
+  }
 }
 ```
 
@@ -112,4 +115,4 @@ ExceptionUnhandledError          # Unhandled runtime exception (not a PyAgentKit
 
 ## License
 
-APACHE 2.0
+Apache 2.0

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/README.md

@@ -13,7 +13,8 @@ A Python library for building tool-calling agents on top of locally-hosted LLMs
 - **Dependency injection** — pass runtime dependencies (database connections, config, etc.) through `AgentDependencies` into tools without polluting tool signatures
 - **Retry logic** — configurable retry budgets separately for tool calls and for response validation failures
 - **Approval gates** — optionally require human confirmation before any tool is executed
-- **Lifecycle hooks** — callbacks for tool calls, retries, successes, and final responses
+- **Lifecycle hooks** — sync and async callbacks for tool calls, retries, successes, and final responses
+- **Validation hook** — supply `on_validate` to run custom response logic and trigger retries or abort
 - **Agent composition** — expose any agent as a tool that another agent can call via `.as_tool()`
 - **Token usage tracking** — cumulative `TokenUsage` object updated after every LLM call
 - **Message history** — persistent within a session, with optional trimming, save, and load
@@ -56,19 +57,21 @@ src/pyagentkit/
 Every agent responds in one of two JSON shapes, validated via Pydantic:
 
 ```json
-// Tool call
 {
   "response": {
     "type": "tool_call",
+    "message": "<why you're calling the tool>",
     "tool_call": { "name": "my_tool", "params": [{ "name": "x", "value": "42" }] }
-  },
-  "message": "Calling my_tool to get the result"
+  }
 }
+```
 
-// Final answer
+```json
 {
-  "response": { "type": "final" },
-  "message": "The answer is 42"
+  "response": {
+    "type": "final",
+    "message": "<your answer or result of your operation(s)>"
+  }
 }
 ```
 
@@ -92,4 +95,4 @@ ExceptionUnhandledError          # Unhandled runtime exception (not a PyAgentKit
 
 ## License
 
-APACHE 2.0
+Apache 2.0

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/USAGE.md

@@ -11,11 +11,12 @@
 5. [Custom Response Models](#5-custom-response-models)
 6. [Async Agent](#6-async-agent)
 7. [Lifecycle Hooks](#7-lifecycle-hooks)
-8. [Agent Composition](#8-agent-composition)
-9. [Message History](#9-message-history)
-10. [Token Usage](#10-token-usage)
-11. [Error Handling](#11-error-handling)
-12. [Configuration Reference](#12-configuration-reference)
+8. [Validation Hook](#8-validation-hook)
+9. [Agent Composition](#9-agent-composition)
+10. [Message History](#10-message-history)
+11. [Token Usage](#11-token-usage)
+12. [Error Handling](#12-error-handling)
+13. [Configuration Reference](#13-configuration-reference)
 
 ---
 
@@ -25,13 +26,13 @@
 from pyagentkit import Agent
 
 agent = Agent(
-    llm_name="<llm_name>",          # Must be pulled in Ollama
+    llm_name="<llm_name>",
     system_prompt="You are a helpful assistant.",
     agent_name="my-agent",
 )
 
 response = agent.handle_response("What is 2 + 2?")
-print(response.message)           # "The answer is 4"
+print(response.response.message)  # "The answer is 4"
 ```
 
 `handle_response` blocks until the agent produces a `final` response or exhausts its retries.
@@ -43,7 +44,6 @@ print(response.message)           # "The answer is 4"
 A tool is any plain Python function that returns a `ToolResult`. It **must** have a docstring — the docstring is what the agent reads to understand what the tool does.
 
 ```python
-from pyagentkit import Agent
 from pyagentkit.definitions import ToolResult, ToolReturnValue
 
 
@@ -73,11 +73,11 @@ def divide(a: float, b: float) -> ToolResult:
 ```python
 agent = Agent(
     llm_name="<llm_name>",
-    tools=[add_numbers, divide],  # registered without approval requirement
+    tools=[add_numbers, divide],
 )
 ```
 
-By default, tools added via the `tools=` constructor parameter require approval (`requires_approval=True`). To skip the prompt, use `add_tool` with `requires_approval=False`:
+Tools passed via the `tools=` constructor parameter use `requires_approval=True` by default, meaning the user will be prompted before each execution. To skip that, register them with `add_tool` instead:
 
 ```python
 agent.add_tool(add_numbers, requires_approval=False)
@@ -138,13 +138,13 @@ class MyDeps(AgentDependencies):
 
 def fetch_user(deps: MyDeps, user_id: str) -> ToolResult:
     """Fetch a user record from the database by user ID."""
-    # deps.db_url and deps.api_key are available here
-    # but `deps` is hidden from the LLM's tool signature
+    # deps.db_url and deps.api_key are available here,
+    # but `deps` is hidden from the LLM's view of the tool signature
     result = f"User {user_id} from {deps.db_url}"
     return ToolResult(return_value=ToolReturnValue.success, content=result)
 
 
-deps = MyDeps(prompt="Find user 42", db_url="postgresql://...", api_key="sk-...")
+deps = MyDeps(db_url="postgresql://...", api_key="sk-...")
 
 agent = Agent(llm_name="<llm_name>", tools=[fetch_user])
 response = agent.handle_response("Find user 42", deps=deps)
@@ -185,7 +185,7 @@ The schema examples injected into the system prompt are generated automatically
 
 ## 6. Async Agent
 
-Use `AsyncAgent` in `asyncio` contexts. The API mirrors `Agent` except all relevant methods are coroutines and the client is `ollama.AsyncClient`.
+Use `AsyncAgent` in `asyncio` contexts. The API mirrors `Agent` except all relevant methods are coroutines and the Ollama client is `ollama.AsyncClient`. Both sync and async callables are accepted for all hooks.
 
 ```python
 import asyncio
@@ -195,7 +195,6 @@ from pyagentkit.definitions import ToolResult, ToolReturnValue
 
 async def get_weather(city: str) -> ToolResult:
     """Return current weather for a given city name."""
-    # ... call a weather API ...
     return ToolResult(return_value=ToolReturnValue.success, content=f"Sunny in {city}")
 
 
@@ -206,20 +205,20 @@ async def main():
         agent_name="weather-agent",
     )
     response = await agent.handle_response("What is the weather in Istanbul?")
-    print(response.message)
+    print(response.response.message)
     agent.dispose()
 
 
 asyncio.run(main())
 ```
 
-> **Important:** Use `await AsyncAgent.create(...)` instead of `AsyncAgent(...)` directly. The constructor is synchronous but environment verification (`_verify_ollama_environment`) is async and must be awaited via `create`.
+> **Important:** Use `await AsyncAgent.create(...)` rather than constructing `AsyncAgent(...)` directly. The constructor is synchronous and cannot run the async Ollama environment check — `create` does this for you. Constructing directly will emit a warning and skip validation.
 
 ---
 
 ## 7. Lifecycle Hooks
 
-Hooks let you observe and log what the agent is doing without modifying its core logic.
+Hooks let you observe what the agent is doing without modifying its core logic. All hooks accept both sync and async callables in `AsyncAgent`; `Agent` accepts sync callables only.
 
 ```python
 from pyagentkit.definitions import AgentResponse
@@ -238,7 +237,7 @@ def on_tool_success(tool_name: str, params: dict) -> None:
 
 
 def on_response(response: AgentResponse) -> None:
-    print(f"[FINAL]   {response.message}")
+    print(f"[FINAL]   {response.response.message}")
 
 
 def on_response_retry(attempt: int, response_str: str, error: str) -> None:
@@ -257,23 +256,54 @@ agent = Agent(
 
 ---
 
-## 8. Agent Composition
+## 8. Validation Hook
+
+`on_validate` runs after every response is parsed and validated by Pydantic, before the agent decides whether to call a tool or return a final answer. Raise `ExceptionAgentError` to send a correction back to the agent and consume a response retry. Raise `ExceptionAgentFatal` to abort immediately.
+
+```python
+from pyagentkit.definitions import AgentResponse
+from pyagentkit.exceptions import ExceptionAgentError
+
+
+def validate(response: AgentResponse) -> None:
+    if response.response.type == "final" and len(response.response.message) < 10:
+        raise ExceptionAgentError("Final response is too short. Please elaborate.")
+
+
+agent = Agent(
+    llm_name="<llm_name>",
+    on_validate=validate,
+)
+```
+
+Async validators work the same way in `AsyncAgent`:
+
+```python
+async def validate(response: AgentResponse) -> None:
+    result = await some_async_check(response.response.message)
+    if not result:
+        raise ExceptionAgentError("Response failed async validation.")
+
+
+agent = await AsyncAgent.create(llm_name="<llm_name>", on_validate=validate)
+```
+
+---
+
+## 9. Agent Composition
 
 Any agent can expose itself as a tool for another agent via `.as_tool()`.
 
 ```python
 from pyagentkit import Agent
-from pyagentkit.definitions import ToolResult, ToolReturnValue
 
 
-# Inner specialist agent
 researcher = Agent(
     llm_name="<llm_name>",
     agent_name="researcher",
     system_prompt="You are a research specialist. Answer factual questions concisely.",
 )
 
-# Outer orchestrator agent
 orchestrator = Agent(
     llm_name="<llm_name>",
     agent_name="orchestrator",
@@ -282,14 +312,14 @@ orchestrator = Agent(
 )
 
 response = orchestrator.handle_response("What is the capital of Japan?")
-print(response.message)
+print(response.response.message)
 ```
 
-`.as_tool()` wraps `handle_response` in a `ToolResult`-returning function and names it after the agent, so the outer agent can discover and call it like any other tool.
+`.as_tool()` wraps `handle_response` in a `ToolResult`-returning function named after the agent. If the inner agent raises a `PyAgentKitError`, it is caught and returned to the outer agent as a recoverable tool error rather than propagating.
 
 ---
 
-## 9. Message History
+## 10. Message History
 
 History is maintained automatically within a session. Each call to `handle_response` appends to the same history, giving the agent memory of prior turns.
 
@@ -298,7 +328,7 @@ agent = Agent(llm_name="<llm_name>", agent_name="chat-agent")
 
 r1 = agent.handle_response("My name is Alice.")
 r2 = agent.handle_response("What is my name?")
-print(r2.message)  # "Your name is Alice."
+print(r2.response.message)  # "Your name is Alice."
 ```
 
 ### Trimming history
@@ -314,7 +344,7 @@ agent = Agent(llm_name="<llm_name>", max_history=20)
 ```python
 agent.save_history("history.json")
 
-# Later, in a new session:
+# In a new session:
 agent.load_history("history.json")
 ```
 
@@ -326,7 +356,7 @@ agent.clear_history()
 
 ---
 
-## 10. Token Usage
+## 11. Token Usage
 
 `agent.token_usage` is a `TokenUsage` object that accumulates across all `handle_response` calls on an instance.
 
@@ -339,16 +369,16 @@ print(agent.token_usage.total_tokens)
 
 ---
 
-## 11. Error Handling
+## 12. Error Handling
 
 ```python
-from pyagentkit.exceptions import (
+from pyagentkit import (
     ExceptionToolRetriesExhausted,
     ExceptionResponseRetriesExhausted,
     ExceptionFatalError,
     ExceptionEnvironmentError,
-    ExceptionUnhandledError,
 )
+from pyagentkit.exceptions import ExceptionUnhandledError
 
 try:
     response = agent.handle_response("Do something complex.")
@@ -364,7 +394,7 @@ except ExceptionUnhandledError as e:
     print(f"Unexpected error: {e}")
 ```
 
-Inside a tool, signal errors to the agent using return values rather than raising exceptions directly:
+Inside a tool, signal errors using return values rather than raising exceptions directly:
 
 ```python
 def risky_tool(path: str) -> ToolResult:
@@ -382,21 +412,22 @@ def risky_tool(path: str) -> ToolResult:
 
 ---
 
-## 12. Configuration Reference
+## 13. Configuration Reference
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `llm_name` | `str` | required | Ollama model name (e.g. `"devstral:22b"`) |
-| `agent_name` | `str \| None` | `llm_name` | Unique name for this agent instance |
+| `llm_name` | `str` | required | Ollama model name |
+| `agent_name` | `str \| None` | `llm_name` | Name for this agent; auto-suffixed if already taken |
 | `system_prompt` | `str \| None` | `""` | Base system prompt prepended to all requests |
 | `instructions` | `str \| None` | `""` | Text appended to every user prompt |
 | `response_model` | `Type[AgentResponse]` | `AgentResponse` | Pydantic model for response validation |
 | `tool_retries` | `int` | `3` | Max tool call retries before raising |
 | `response_retries` | `int` | `3` | Max response validation retries before raising |
 | `num_ctx` | `int` | `8192` | Ollama context window size |
-| `temperature` | `float \| None` | `None` | Sampling temperature |
-| `top_p` | `float \| None` | `None` | Nucleus sampling probability |
-| `seed` | `int \| None` | `None` | Random seed for reproducibility |
+| `temperature` | `float` | `0.0` | Sampling temperature |
+| `top_p` | `float` | `0.0` | Nucleus sampling probability |
+| `top_k` | `float` | `0.0` | Top-k sampling |
+| `seed` | `int` | `42` | Random seed for reproducibility |
 | `ollama_url` | `str \| None` | `None` | Custom Ollama host URL; uses default if `None` |
 | `tools` | `list \| None` | `None` | Tool functions to register on init |
 | `max_history` | `int \| None` | `None` | Max non-system messages to retain |
@@ -407,16 +438,4 @@ def risky_tool(path: str) -> ToolResult:
 | `on_tool_success` | callable | `None` | Hook called on tool success |
 | `on_response` | callable | `None` | Hook called on final response |
 | `on_response_retry` | callable | `None` | Hook called on response validation failure |
-
-### Agent lifecycle
-
-```python
-agent = Agent(llm_name="<llm_name>", agent_name="my-agent")
-
-# Use the agent ...
-
-# When done, unregister and clean up the logger:
-agent.dispose()
-```
-
-Each agent name must be unique within the `Agent` or `AsyncAgent` registry. Calling `dispose()` frees the name so it can be reused.
+| `on_validate` | callable | `None` | Hook called after parsing; raise to trigger retry or abort |

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyagentkit"
-version = "1.0.0"
+version = "1.1.0"
 description = "Agent toolkit for Ollama"
 readme = "README.md"
 requires-python = ">=3.12"

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/src/pyagentkit/agent.py

@@ -5,6 +5,7 @@ import json
 import logging
 import inspect
 from typing import (
+    Any,
     Callable,
     ClassVar,
     Generic,
@@ -184,19 +185,22 @@ class Agent(Generic[T]):
             return result
 
         # Canonical examples
-        tool_example = {
+        tool_example: dict[str, Any] = {
             "response": {
                 "type": "tool_call",
+                "message": "<why you're calling the tool>",
                 "tool_call": {
                     "name": "<tool_name>",
                     "params": [{"name": "<param_name>", "value": "<param_value>"}],
                 },
             },
-            "message": "<why you're calling the tool>",
         }
-        final_example = {
-            "response": {"type": "final"},
-            "message": "<your answer or result of your operation(s)>",
+
+        final_example: dict[str, Any] = {
+            "response": {
+                "type": "final",
+                "message": "<your answer or result of your operation(s)>",
+            },
         }
 
         # Append any subclass-defined extra fields to both examples
@@ -287,9 +291,10 @@ class Agent(Generic[T]):
 
         def run_agent(prompt: str) -> ToolResult:
             try:
-                response = agent.handle_response(prompt=prompt, deps=deps)
+                output = agent.handle_response(prompt=prompt, deps=deps)
                 return ToolResult(
-                    return_value=ToolReturnValue.success, content=response.message
+                    return_value=ToolReturnValue.success,
+                    content=output.response.message,
                 )
             except PyAgentKitError as err:
                 return ToolResult(return_value=ToolReturnValue.error, content=str(err))
@@ -310,9 +315,10 @@ class Agent(Generic[T]):
         agent_name: str | None = None,
         response_model: Type[T] = AgentResponse,
         num_ctx: int = 8192,
-        temperature: float | None = None,
-        top_p: float | None = None,
-        seed: int | None = None,
+        temperature: float = 0.0,
+        top_p: float = 0.0,
+        top_k: float = 0.0,
+        seed: int = 42,
         ollama_url: str | None = None,
         tools: list[TypeTool] | None = None,
         max_history: int | None = None,
@@ -352,13 +358,13 @@ class Agent(Generic[T]):
         self.logger.addHandler(handler)
 
         # Create Ollama options dictionary
-        self.ollama_options: dict = {"num_ctx": num_ctx}
-        if temperature:
-            self.ollama_options["temperature"] = temperature
-        if top_p:
-            self.ollama_options["top_p"] = top_p
-        if seed:
-            self.ollama_options["seed"] = seed
+        self.ollama_options: dict = {
+            "num_ctx": num_ctx,
+            "temperature": temperature,
+            "seed": seed,
+            "top_p": top_p,
+            "top_k": top_k,
+        }
 
         # Create custom Ollama client
         self.ollama_url = ollama_url
@@ -417,9 +423,18 @@ class Agent(Generic[T]):
         """
         result = "Your response failed validation, handle the following issues and generate your answer with the same `type`\nEncountered errors:"
         for error in errors:
-            result += f"\nType: {error['type']}"
-            result += f"\nField: {'.'.join(map(str, error['loc']))}"
-            result += f"\nError message: {error['msg']}"
+            err_type = error.get("type")
+            err_fields = error.get("loc")
+            if err_type == "missing":
+                result += "\nYou are missing field(s):"
+                for field in err_fields:
+                    result += f"\n- {field}"
+            elif err_type == "json_invalid":
+                result += "Your response wasn't valid json. Make sure your response is perfect JSON"
+            else:
+                err_msg = error.get("msg")
+                result += f"\nType: {err_type}\nField: {'.'.join(map(str, err_fields))}\nMessage: {err_msg}"
+
         result += "\nCRITICAL: Fix the errors and respond ONLY with valid JSON. Make sure you close out your curly braces ('{'). Do NOT include any markdown formatting."
         return result
 
@@ -569,6 +584,7 @@ class Agent(Generic[T]):
             raise ExceptionToolError(invalid_param_message)
 
         # Call tool and get return value
+        self.logger.debug("Calling tool %s with params %s", tool_name, str(kwargs))
         self._on_tool_call(tool_name=tool_name, params=kwargs)
         try:
             tool_return = accepted_tool.function(**kwargs)
@@ -728,7 +744,7 @@ Complete the user task using the available tools and schemas.
             },
         )
         while response_try < self.response_retries and tool_try < self.tool_retries:
-            self.logger.debug("Response try: %s", response_try)
+            self.logger.debug("Response try: %s, Tool try: %s", response_try, tool_try)
             content = ""
             try:
                 self._trim_history()
@@ -746,26 +762,25 @@ Complete the user task using the available tools and schemas.
                     total_tokens=_prompt_tokens + _response_tokens,
                 )
                 if self.think and response.message.thinking:
-                    self.logger.info(response.message.thinking)
+                    self.logger.info("Thought: %s", response.message.thinking)
                 content = response.message.content
                 if content is None:
                     raise RuntimeError(
                         f"Failed to get response from agent {self.agent_name}"
                     )
-                self.logger.debug(
-                    "Content from agent %s:\n%s", self.agent_name, content
-                )
-                # Append the assistant message because it doesn't know that it
-                # actually did anything
+                self.logger.debug("Content:\n%s", content)
                 self.message_history.append({"role": "assistant", "content": content})
 
                 stripped_content = self._strip_markdown_formatting(content)
                 validated = self.response_model.model_validate_json(stripped_content)
                 validated = validated.model_copy(
                     update={
-                        "message": self._strip_markdown_formatting(validated.message)
+                        "message": self._strip_markdown_formatting(
+                            validated.response.message
+                        )
                     }
                 )
+                self.logger.info("Message: %s", validated.response.message)
 
                 self._on_validate(response=validated)
                 if validated.response.type == "final":
@@ -782,6 +797,7 @@ Complete the user task using the available tools and schemas.
 
             except ValidationError as exc:
                 error_message = self._print_validation_errors(exc.errors())
+                self.logger.debug("Validation errors:\n%s\n", exc.errors())
                 self.message_history.append({"role": "user", "content": error_message})
                 self._on_response_retry(
                     response_try=response_try,

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/src/pyagentkit/async_agent.py

@@ -10,6 +10,7 @@ import logging
 import inspect
 import asyncio
 from typing import (
+    Any,
     Callable,
     ClassVar,
     Generic,
@@ -191,19 +192,22 @@ class AsyncAgent(Generic[T]):
             return result
 
         # Canonical examples
-        tool_example = {
+        tool_example: dict[str, Any] = {
             "response": {
                 "type": "tool_call",
+                "message": "<why you're calling the tool>",
                 "tool_call": {
                     "name": "<tool_name>",
                     "params": [{"name": "<param_name>", "value": "<param_value>"}],
                 },
             },
-            "message": "<why you're calling the tool>",
         }
-        final_example = {
-            "response": {"type": "final"},
-            "message": "<your answer or result of your operation(s)>",
+
+        final_example: dict[str, Any] = {
+            "response": {
+                "type": "final",
+                "message": "<your answer or result of your operation(s)>",
+            },
         }
 
         # Append any subclass-defined extra fields to both examples
@@ -298,9 +302,10 @@ class AsyncAgent(Generic[T]):
 
         async def run_agent(prompt: str) -> ToolResult:
             try:
-                response = await agent.handle_response(prompt=prompt, deps=deps)
+                output = await agent.handle_response(prompt=prompt, deps=deps)
                 return ToolResult(
-                    return_value=ToolReturnValue.success, content=response.message
+                    return_value=ToolReturnValue.success,
+                    content=output.response.message,
                 )
             except PyAgentKitError as err:
                 return ToolResult(return_value=ToolReturnValue.error, content=str(err))
@@ -321,9 +326,10 @@ class AsyncAgent(Generic[T]):
         agent_name: str | None = None,
         response_model: Type[T] = AgentResponse,
         num_ctx: int = 8192,
-        temperature: float | None = None,
-        top_p: float | None = None,
-        seed: int | None = None,
+        temperature: float = 0.0,
+        top_p: float = 0.0,
+        top_k: float = 0.0,
+        seed: int = 42,
         ollama_url: str | None = None,
         tools: list[TypeAsyncTool] | None = None,
         max_history: int | None = None,
@@ -368,13 +374,13 @@ class AsyncAgent(Generic[T]):
         )
 
         # Create Ollama options dictionary
-        self.ollama_options: dict = {"num_ctx": num_ctx}
-        if temperature:
-            self.ollama_options["temperature"] = temperature
-        if top_p:
-            self.ollama_options["top_p"] = top_p
-        if seed:
-            self.ollama_options["seed"] = seed
+        self.ollama_options: dict = {
+            "num_ctx": num_ctx,
+            "temperature": temperature,
+            "seed": seed,
+            "top_p": top_p,
+            "top_k": top_k,
+        }
 
         # Create custom Ollama client
         self.ollama_url = ollama_url
@@ -438,9 +444,17 @@ class AsyncAgent(Generic[T]):
         """
         result = "Your response failed validation, handle the following issues and generate your answer with the same `type`\nEncountered errors:"
         for error in errors:
-            result += f"\nType: {error['type']}"
-            result += f"\nField: {'.'.join(map(str, error['loc']))}"
-            result += f"\nError message: {error['msg']}"
+            err_type = error.get("type")
+            err_fields = error.get("loc")
+            if err_type == "missing":
+                result += "\nYou are missing field(s):"
+                for field in err_fields:
+                    result += f"\n- {field}"
+            elif err_type == "json_invalid":
+                result += "Your response wasn't valid json. Make sure your response is perfect JSON"
+            else:
+                err_msg = error.get("msg")
+                result += f"\nType: {err_type}\nField: {'.'.join(map(str, err_fields))}\nMessage: {err_msg}"
         result += "\nCRITICAL: Fix the errors and respond ONLY with valid JSON. Make sure you close out your curly braces ('{'). Do NOT include any markdown formatting."
         return result
 
@@ -606,6 +620,7 @@ class AsyncAgent(Generic[T]):
             )
             raise ExceptionToolError(full_error)
 
+        self.logger.debug("Calling tool %s with params %s", tool_name, str(kwargs))
         await self._on_tool_call(tool_name=tool_name, params=kwargs)
         try:
             if inspect.iscoroutinefunction(accepted_tool.function):
@@ -773,7 +788,7 @@ Complete the user task using the available tools and schemas.
 
         while response_try < self.response_retries and tool_try < self.tool_retries:
             content = ""
-            self.logger.debug("Response try: %s", response_try)
+            self.logger.debug("Response try: %s, Tool try: %s", response_try, tool_try)
             try:
                 self._trim_history()
                 response = await self.ollama_client.chat(
@@ -796,18 +811,19 @@ Complete the user task using the available tools and schemas.
                     raise RuntimeError(
                         f"Failed to get response from agent {self.agent_name}"
                     )
-                self.logger.debug(
-                    "Content from agent %s:\n%s", self.agent_name, content
-                )
+                self.logger.debug("Content:\n%s", content)
                 self.message_history.append({"role": "assistant", "content": content})
 
                 stripped_content = self._strip_markdown_formatting(content)
                 validated = self.response_model.model_validate_json(stripped_content)
                 validated = validated.model_copy(
                     update={
-                        "message": self._strip_markdown_formatting(validated.message)
+                        "message": self._strip_markdown_formatting(
+                            validated.response.message
+                        )
                     }
                 )
+                self.logger.info("Message: %s", validated.response.message)
 
                 await self._on_validate(response=validated)
                 if validated.response.type == "final":
@@ -823,6 +839,8 @@ Complete the user task using the available tools and schemas.
 
             except ValidationError as exc:
                 error_message = self._print_validation_errors(exc.errors())
+                self.logger.debug("Validation errors:\n%s\n", exc.errors())
+                self.logger.debug("Validation error prompt: \n%s\n", error_message)
                 self.message_history.append({"role": "user", "content": error_message})
                 await self._on_response_retry(
                     response_try=response_try,

{pyagentkit-1.0.0 → pyagentkit-1.1.0}/src/pyagentkit/definitions.py

@@ -16,7 +16,11 @@ class ToolReturnValue(Enum):
     fatal = "fatal"
 
 
-class FinalResponse(BaseModel):
+class BaseResponse(BaseModel):
+    message: str
+
+
+class FinalResponse(BaseResponse):
     type: Literal["final"]
 
 
@@ -38,14 +42,13 @@ class tool_call_schema(BaseModel):
     params: list[tool_params]
 
 
-class ToolCallResponse(BaseModel):
+class ToolCallResponse(BaseResponse):
     type: Literal["tool_call"]
     tool_call: tool_call_schema
 
 
 class AgentResponse(BaseModel):
     response: Union[FinalResponse, ToolCallResponse] = Field(discriminator="type")
-    message: str
 
 
 # Tool types