agentx-dev 3.0.2__tar.gz → 3.0.5__tar.gz

{agentx_dev-3.0.2/agentx_dev.egg-info → agentx_dev-3.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-dev
-Version: 3.0.2
+Version: 3.0.5
 Summary: A lightweight LLM agent framework with multi-agent orchestration (Supervisor + dynamic specialist spawning), permission-gated default tools, MCP integration, and prompt-template presets.
 Author-email: Bruce-Arhin Shadrach <brucearhin098@gmail.com>
 License: MIT License

{agentx_dev-3.0.2 → agentx_dev-3.0.5}/agentx_dev/Agents/Agent.py

@@ -99,8 +99,28 @@ class StandardParser(_ParserMixin, BaseModel):
     - from_json: Creates an instance from a JSON string.
     - from_function_call: Creates an instance from a tool-call args dict.
     """
-    action: str = Field("The action to take", alias='action')
-    action_input: str | Dict | List = Field("The input to the action", alias='action_input')
+    action: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Must be one of the registered tool names shown "
+            "in the system prompt, OR the exact literal string "
+            "'Final_Answer' (with underscore) when you are ready to "
+            "return the completed answer. Do NOT put natural-language "
+            "response text here — that goes in action_input."
+        ),
+        alias='action',
+    )
+    action_input: str | Dict | List = Field(
+        default="",
+        description=(
+            "REQUIRED. When action is a tool name, this is the JSON "
+            "object matching that tool's argument schema (or the "
+            "single string the tool expects). When action is "
+            "'Final_Answer', this is the actual answer TEXT you want "
+            "the user to see."
+        ),
+        alias='action_input',
+    )
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -150,8 +170,27 @@ class Instruction_Tuned_(_ParserMixin, BaseModel):
     - action: str, the action to take or final answer.
     - action_input: str, Dict, or List, the input to the action.
     """
-    action: str = Field("The action to take OR Final Answer", alias="action")
-    action_input: str | Dict | List = Field("The input to the action OR You should put what you want to return to use here and return to user immediately", alias="action_input")
+    action: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Must be one of the registered tool names shown "
+            "in the system prompt, OR the exact literal string "
+            "'Final_Answer' (with underscore) when you are ready to "
+            "return the completed answer. Never put natural-language "
+            "response text here — that goes in action_input."
+        ),
+        alias='action',
+    )
+    action_input: str | Dict | List = Field(
+        default="",
+        description=(
+            "REQUIRED. When action is a tool name, this is the JSON "
+            "object matching that tool's schema (or the single string "
+            "it expects). When action is 'Final_Answer', this is the "
+            "actual answer TEXT you want the user to see."
+        ),
+        alias='action_input',
+    )
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -172,9 +211,36 @@ class React_(_ParserMixin, BaseModel):
     - action: str, the action to take or final answer.
     - action_input: str, Dict, or List, the input to the action.
     """
-    Thought: str = Field('The Agent Thoughts', alias='Thought')
-    action: str = Field("The action to take OR Final Answer", alias="action")
-    action_input: str | Dict | List = Field("The input to the action OR You should put what you want to return to use here and return to user immediately", alias="action_input")
+    Thought: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Brief reasoning for THIS turn: what the last "
+            "tool returned + what you'll do differently now. Keep it "
+            "concrete, not generic."
+        ),
+        alias='Thought',
+    )
+    action: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Must be one of the registered tool names shown "
+            "in the system prompt, OR the exact literal string "
+            "'Final_Answer' (with underscore) when you are ready to "
+            "return the completed answer. Never put natural-language "
+            "response text here — that goes in action_input."
+        ),
+        alias='action',
+    )
+    action_input: str | Dict | List = Field(
+        default="",
+        description=(
+            "REQUIRED. When action is a tool name, this is the JSON "
+            "object matching that tool's schema (or the single string "
+            "it expects). When action is 'Final_Answer', this is the "
+            "actual answer TEXT you want the user to see."
+        ),
+        alias='action_input',
+    )
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -198,14 +264,35 @@ class ChainOfThought(_ParserMixin, BaseModel):
     ``instance.action`` / ``instance.action_input`` uniformly across every
     AgentType — no more parser-specific field lookups.
     """
-    Thought: str = Field('The step-by-step reasoning', alias='Thought')
+    Thought: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Step-by-step reasoning covering: (a) what the "
+            "user asked; (b) what info is needed; (c) which tool fits; "
+            "(d) the exact argument shape; (e) whether one call finishes."
+        ),
+        alias='Thought',
+    )
     action: str = Field(
-        "The action to take or Final Answer",
+        default="",
+        description=(
+            "REQUIRED. Must be one of the registered tool names shown "
+            "in the system prompt, OR the exact literal string "
+            "'Final_Answer' (with underscore) when you are ready to "
+            "return the completed answer. Never put natural-language "
+            "response text here — that goes in action_input."
+        ),
         validation_alias=AliasChoices("action", "Action"),
         serialization_alias="action",
     )
     action_input: str | Dict | List = Field(
-        "The input to the action",
+        default="",
+        description=(
+            "REQUIRED. When action is a tool name, this is the JSON "
+            "object matching that tool's schema (or the single string "
+            "it expects). When action is 'Final_Answer', this is the "
+            "actual answer TEXT you want the user to see."
+        ),
         validation_alias=AliasChoices("action_input", "Action_Input"),
         serialization_alias="action_input",
     )
@@ -224,8 +311,27 @@ class ZeroShot(_ParserMixin, BaseModel):
     """
     A Pydantic model representing the Zero-Shot prompt template.
     """
-    action: str = Field("The action to take", alias='action')
-    action_input: str | Dict | List = Field("The input to the action", alias='action_input')
+    action: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Must be one of the registered tool names shown "
+            "in the system prompt, OR the exact literal string "
+            "'Final_Answer' (with underscore) when you are ready to "
+            "return the completed answer. Never put natural-language "
+            "response text here — that goes in action_input."
+        ),
+        alias='action',
+    )
+    action_input: str | Dict | List = Field(
+        default="",
+        description=(
+            "REQUIRED. When action is a tool name, this is the JSON "
+            "object matching that tool's schema (or the single string "
+            "it expects). When action is 'Final_Answer', this is the "
+            "actual answer TEXT you want the user to see."
+        ),
+        alias='action_input',
+    )
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -241,8 +347,27 @@ class FewShot(_ParserMixin, BaseModel):
     """
     A Pydantic model representing the Few-Shot prompt template.
     """
-    action: str = Field("The action to take", alias='action')
-    action_input: str | Dict | List = Field("The input to the action", alias='action_input')
+    action: str = Field(
+        default="",
+        description=(
+            "REQUIRED. Must be one of the registered tool names shown "
+            "in the system prompt, OR the exact literal string "
+            "'Final_Answer' (with underscore) when you are ready to "
+            "return the completed answer. Never put natural-language "
+            "response text here — that goes in action_input."
+        ),
+        alias='action',
+    )
+    action_input: str | Dict | List = Field(
+        default="",
+        description=(
+            "REQUIRED. When action is a tool name, this is the JSON "
+            "object matching that tool's schema (or the single string "
+            "it expects). When action is 'Final_Answer', this is the "
+            "actual answer TEXT you want the user to see."
+        ),
+        alias='action_input',
+    )
 
     model_config = ConfigDict(populate_by_name=True)
 

{agentx_dev-3.0.2 → agentx_dev-3.0.5}/agentx_dev/Runner/AgentRun.py

@@ -114,6 +114,34 @@ class CircuitBreaker:
 _NO_ARG = object()
 
 
+# Set of case-insensitive strings that should be treated as the model's
+# "I'm done, return this as the final answer" signal. Exact string
+# "Final_Answer" is the canonical form the prompt template teaches;
+# the tolerant variants exist because under use_function_calling=True
+# the schema doesn't constrain `action` to any specific value, so
+# LLMs (especially gpt-4o-mini) emit "Final Answer" (with space) or
+# "final_answer" (lowercase) or "finalanswer" (no separator). Any of
+# those should end the loop, not get routed to Tool_Runner.
+#
+# Deliberately excludes bare "answer" or "final" — those are too
+# likely to collide with a user-defined tool of the same name.
+_TERMINAL_ACTION_VARIANTS = frozenset({
+    "final_answer", "finalanswer",
+})
+
+
+def _is_terminal_action(action: str) -> bool:
+    """True if ``action`` should end the loop with action_input as the
+    final answer. Accepts Final_Answer, Final Answer, final_answer,
+    FINAL_ANSWER, finalanswer — any capitalization + underscore/space
+    variant. Empty string is not terminal (caller handles that as
+    'unrecognized action' via the implicit-final guardrail)."""
+    if not action or not isinstance(action, str):
+        return False
+    normalized = action.strip().lower().replace(" ", "_").replace("-", "_")
+    return normalized in _TERMINAL_ACTION_VARIANTS
+
+
 def _build_sandbox_hint(perms: Any) -> Optional[str]:
     """Generate a short block describing where the runner is allowed to
     operate on disk. Injected into the system prompt when Permissions
@@ -1019,6 +1047,7 @@ class AgentRunner:
         permissions: Any = None,
         include_denied_tools: bool = False,
         system_addendum: Optional[str] = None,
+        strict_tool_dispatch: bool = False,
     ):
         # PEP 8 alias: prefer lowercase `agent=`. Either argument works; passing
         # both raises so misuse is loud rather than silently ambiguous.
@@ -1104,6 +1133,16 @@ class AgentRunner:
         else:
             self.system_addendum = system_addendum
 
+        # When True: on unknown-tool dispatch, feed the model an error
+        # observation ("that tool doesn't exist; use one of [X,Y] or
+        # Final_Answer") and let the loop iterate rather than
+        # immediately falling to implicit-final. Only applies when the
+        # unknown action looks like a tool identifier (no spaces) —
+        # natural-language actions still go straight to implicit-final
+        # since retrying makes no sense there. Default False keeps
+        # the 3.0.4 behavior.
+        self.strict_tool_dispatch = strict_tool_dispatch
+
         self.auto_cache = auto_cache and config.caching_enabled
         self.auto_memory = auto_memory and config.memory_enabled
         _setup = _ensure_auto_setup() if (self.auto_cache or self.auto_memory) else None
@@ -1323,53 +1362,38 @@ class AgentRunner:
             step_description = f"Step {count}: {action} with {action_input}"
             steps.append(step_description)
 
-            if action == "Final_Answer":
+            # Terminal action check — tolerant matching so the loop ends
+            # for the canonical "Final_Answer" AND for the LLM's common
+            # variants ("Final Answer", "final_answer", "finalanswer").
+            # Under use_function_calling=True the schema doesn't
+            # constrain `action` to any spelling, so we accept them all.
+            if _is_terminal_action(action):
                 final_answer = action_input
                 yield {"type": "final", "content": final_answer}
                 break
 
-            # Guardrail for use_function_calling=True: the model is forced
-            # to call the parser tool (React_ / FewShot / etc.) and fills
-            # in `action` + `action_input`. Nothing in the parser schema
-            # constrains `action` to a real tool name, so the model can
-            # (and does) put its natural-language closing response there
-            # — e.g. action = "Provide a response to the athlete."
-            # Without this guardrail the runner would try to dispatch
-            # a tool with that name, get "not found", and the turn dies.
-            # Detection: action isn't Final_Answer AND isn't in the
-            # registry. Treat the whole turn as an implicit Final_Answer
-            # built from whatever text the model provided (thought +
-            # action + action_input, whichever are present).
-            known_tools = set(self.func) | set(self.args)
-            if action and action != "Final_Answer" and action not in known_tools:
-                parts: List[str] = []
-                if thought:
-                    parts.append(str(thought))
-                # action itself may BE the response text
-                if action:
-                    parts.append(str(action))
-                # action_input often carries the actual body
-                if action_input and str(action_input).strip():
-                    parts.append(str(action_input))
-                final_answer = "\n\n".join(parts) or (
-                    "(agent emitted an unrecognized action and no text)"
-                )
+            # Normalize BEFORE the known-tools check — OpenAI's FC path
+            # sometimes returns tool names with a "functions." prefix
+            # ("functions.get_my_scores" instead of "get_my_scores").
+            # Without this, a valid tool call falls through to the
+            # implicit-final guardrail, which then leaks the model's
+            # internal Thought into user-visible text. Rewrite `action`
+            # here so the rest of the loop uses the canonical name.
+            normalized_action = self.registry._normalize_tool_name(action)
+            if normalized_action != action:
                 if self.verbose:
                     print(
-                        f"\x1B[1;33m[loop] implicit-final: action "
-                        f"'{action[:60]}' is not a registered tool; "
-                        f"treating turn as Final_Answer\x1B[0m"
+                        f"\x1B[3;33m[loop] normalized action "
+                        f"'{action}' -> '{normalized_action}'\x1B[0m"
                     )
-                yield {"type": "final", "content": final_answer}
-                break
-
-            # Loop-level spiral check — same (action, args) as the last
-            # turn? Count it. Three in a row and we bail with a synthesized
-            # Final_Answer built from whatever real data was gathered
-            # before the spiral. Catches BOTH the "refused" spiral and
-            # the "tool not found" spiral (gpt-4o-mini did both in
-            # traces). Cheaper than dispatch — we abort before the tool
-            # even runs on the 3rd repeat.
+                action = normalized_action
+
+            # Loop-level spiral check — 3 identical (action, args) in a
+            # row and we bail. Placed BEFORE the known-tools branch so
+            # it catches BOTH kinds of spiral: a valid tool getting
+            # re-dispatched (dup-guard also catches this at the tool
+            # layer), and an unknown tool being retried via strict-mode
+            # (dup-guard would never see those since dispatch skips them).
             try:
                 action_sig = f"{action}::{json.dumps(action_input, sort_keys=True, default=repr)}"
             except Exception:
@@ -1404,6 +1428,102 @@ class AgentRunner:
                 yield {"type": "final", "content": final_answer}
                 break
 
+            # Guardrail: the model emitted an `action` value that is
+            # neither a terminal-answer variant NOR a registered tool
+            # (even after normalization). Two scenarios trigger this:
+            #   1. use_function_calling=True + missing schema guidance:
+            #      the model stuffs its natural-language response text
+            #      into `action` (e.g. "Provide a response to the
+            #      athlete."). Route to final so the loop terminates.
+            #   2. action="" (missing field, Pydantic default).
+            # NEVER include `Thought` in the user-facing final — the
+            # Thought is internal reasoning ("The user needs their
+            # scores; I'll fetch them") and leaking it to the user
+            # exposes the agent's introspection. Prefer action_input
+            # (that's what the model wanted the user to see). Only fall
+            # back to `action` when action_input is empty AND action
+            # looks like natural-language text (contains a space, not
+            # just an identifier).
+            known_tools = set(self.func) | set(self.args)
+            if not action or action not in known_tools:
+                # Strict mode: when the unknown `action` looks like a
+                # tool identifier (no spaces, short), assume the model
+                # was TRYING to call a tool and misnamed it. Feed an
+                # error observation back so the model can retry with
+                # a valid name, instead of collapsing to implicit-final
+                # after the very first mistake. The existing dup-guard
+                # + loop-level circuit breaker still bound retries.
+                # Only skipped when: strict mode is off, we've hit
+                # max_iterations, or the action is clearly the model's
+                # response text (contains a space → natural language).
+                looks_like_tool_id = (
+                    bool(action) and " " not in action and len(action) < 80
+                )
+                if (
+                    self.strict_tool_dispatch
+                    and looks_like_tool_id
+                    and count < self.max_iterations
+                ):
+                    available = sorted(known_tools)
+                    error_content = (
+                        f"[framework] error: '{action}' is not a "
+                        f"registered tool. Available tools: {available}. "
+                        f"Options: (1) call one of them with the correct "
+                        f"argument shape; (2) emit action=\"Final_Answer\" "
+                        f"with your final response text in action_input "
+                        f"if you're done."
+                    )
+                    tc_id = getattr(self, "_last_function_call_id", None) if self.use_function_calling else None
+                    err_msg = {
+                        "role": "tool" if tc_id else "function",
+                        "name": "tool_call_error",
+                        "content": error_content,
+                    }
+                    if tc_id:
+                        err_msg["tool_call_id"] = tc_id
+                    working_history.append(err_msg)
+                    yield {
+                        "type": "tool_result",
+                        "name": action,
+                        "result": error_content,
+                        "is_error": True,
+                    }
+                    if self.verbose:
+                        print(
+                            f"\x1B[1;33m[loop] strict-retry: action "
+                            f"'{action[:60]}' unknown; feeding error "
+                            f"back so the model can retry\x1B[0m"
+                        )
+                    self._last_function_call_id = None
+                    count += 1
+                    continue
+
+                # Non-strict OR strict-can't-help path: implicit-final.
+                # Prefer action_input; fall back to action-as-text ONLY
+                # when it's natural language (has spaces). NEVER leak
+                # Thought — it's internal reasoning that shouldn't reach
+                # a user, especially in third-person-persona apps.
+                if action_input and str(action_input).strip():
+                    final_answer = str(action_input)
+                elif action and action.strip() and " " in action:
+                    final_answer = str(action)
+                else:
+                    final_answer = (
+                        "(agent emitted an unrecognized action and no "
+                        "answer text — try rephrasing or re-run)"
+                    )
+                if self.verbose:
+                    preview = (action or "<empty>")[:60]
+                    print(
+                        f"\x1B[1;33m[loop] implicit-final: action "
+                        f"'{preview}' is not a registered tool and not "
+                        f"a Final_Answer variant; returning "
+                        f"action_input as final (Thought NOT leaked)"
+                        f"\x1B[0m"
+                    )
+                yield {"type": "final", "content": final_answer}
+                break
+
             yield {"type": "tool_call", "name": action, "args": action_input}
             if self.verbose:
                 print(f"\x1B[3;33m[tool] Invoking '{action}' with args: {action_input}\x1B[0m")

{agentx_dev-3.0.2 → agentx_dev-3.0.5}/agentx_dev/Runner/AsyncAgentRun.py

@@ -13,7 +13,7 @@ from agentx_dev.ChatModel import BaseChatModel
 from agentx_dev.Agents.Agent import StandardParser, ToolCall, ToolError
 from agentx_dev.Tools import StandardTool, StructuredTool, logger
 from agentx_dev.AsyncTools import AsyncStandardTool, AsyncStructuredTool
-from agentx_dev.Runner.AgentRun import ToolRegistry
+from agentx_dev.Runner.AgentRun import ToolRegistry, _is_terminal_action
 from typing import Dict, Callable, List, Type, Optional, Any, AsyncIterator
 from pydantic import BaseModel, Field
 import asyncio
@@ -86,6 +86,7 @@ class AsyncAgentRunner:
         agent: AgentFormattor | AgentPrompt | str | None = None,
         permissions: Any = None,
         include_denied_tools: bool = False,
+        strict_tool_dispatch: bool = False,
     ):
         if Agent is not None and agent is not None:
             raise TypeError("AsyncAgentRunner received both 'Agent' and 'agent'; pass only one.")
@@ -133,6 +134,8 @@ class AsyncAgentRunner:
                 "are mutually exclusive. Function-calling routes through the "
                 "AgentType parser; native binding skips it. Pick one."
             )
+        # See AgentRunner.__init__ for the strict_tool_dispatch contract.
+        self.strict_tool_dispatch = strict_tool_dispatch
 
         self.auto_cache = auto_cache and config.caching_enabled
         self.auto_memory = auto_memory and config.memory_enabled
@@ -493,7 +496,10 @@ class AsyncAgentRunner:
             step_description = f"Step {count}: {action} with {action_input}"
             steps.append(step_description)
 
-            if action == "Final_Answer":
+            # Terminal-action check — tolerant of format variants that
+            # LLMs emit under use_function_calling=True where the schema
+            # doesn't constrain `action` to a specific spelling.
+            if _is_terminal_action(action):
                 final_answer = action_input
                 break
 
@@ -503,6 +509,82 @@ class AsyncAgentRunner:
             elif thought:
                 logger.info(f"thought: {thought}")
 
+            # Strip OpenAI's "functions." prefix before the known-tools
+            # check — otherwise a valid tool call falls through to the
+            # implicit-final guardrail and leaks Thought as user text.
+            normalized_action = self.registry._normalize_tool_name(action)
+            if normalized_action != action:
+                if self.verbose:
+                    print(
+                        f"\x1B[3;33m[loop] normalized action "
+                        f"'{action}' -> '{normalized_action}'\x1B[0m"
+                    )
+                action = normalized_action
+
+            # Implicit-final guardrail — see the sync AgentRunner for
+            # the full rationale. If strict_tool_dispatch=True AND the
+            # unknown action looks like a tool identifier (no spaces)
+            # AND we still have iteration budget, feed an error
+            # observation back to the model and let it retry.
+            known_tools = set(self.registry.sync_std) | set(self.registry.sync_struct) \
+                        | set(self.registry.async_std) | set(self.registry.async_struct)
+            if not action or action not in known_tools:
+                looks_like_tool_id = (
+                    bool(action) and " " not in action and len(action) < 80
+                )
+                if (
+                    self.strict_tool_dispatch
+                    and looks_like_tool_id
+                    and count < self.max_iterations
+                ):
+                    available = sorted(known_tools)
+                    error_content = (
+                        f"[framework] error: '{action}' is not a "
+                        f"registered tool. Available tools: {available}. "
+                        f"Options: (1) call one of them with the correct "
+                        f"argument shape; (2) emit action=\"Final_Answer\" "
+                        f"with your final response text in action_input "
+                        f"if you're done."
+                    )
+                    tc_id = getattr(self, "_last_function_call_id", None) if self.use_function_calling else None
+                    err_msg = {
+                        "role": "tool" if tc_id else "function",
+                        "name": "tool_call_error",
+                        "content": error_content,
+                    }
+                    if tc_id:
+                        err_msg["tool_call_id"] = tc_id
+                    working_history.append(err_msg)
+                    if self.verbose:
+                        print(
+                            f"\x1B[1;33m[loop] strict-retry: action "
+                            f"'{action[:60]}' unknown; feeding error "
+                            f"back so the model can retry\x1B[0m"
+                        )
+                    self._last_function_call_id = None
+                    count += 1
+                    continue
+
+                # Non-strict OR strict-can't-help: implicit-final.
+                if action_input and str(action_input).strip():
+                    final_answer = str(action_input)
+                elif action and action.strip() and " " in action:
+                    final_answer = str(action)
+                else:
+                    final_answer = (
+                        "(agent emitted an unrecognized action and no "
+                        "answer text — try rephrasing or re-run)"
+                    )
+                if self.verbose:
+                    preview = (action or "<empty>")[:60]
+                    print(
+                        f"\x1B[1;33m[loop] implicit-final: action "
+                        f"'{preview}' is not a registered tool and not "
+                        f"a Final_Answer variant; returning action_input "
+                        f"as final (Thought NOT leaked)\x1B[0m"
+                    )
+                break
+
             if self.verbose:
                 print(f"\x1B[3;33m[tool] Invoking '{action}' with args: {action_input}\x1B[0m")
             else:

{agentx_dev-3.0.2 → agentx_dev-3.0.5/agentx_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-dev
-Version: 3.0.2
+Version: 3.0.5
 Summary: A lightweight LLM agent framework with multi-agent orchestration (Supervisor + dynamic specialist spawning), permission-gated default tools, MCP integration, and prompt-template presets.
 Author-email: Bruce-Arhin Shadrach <brucearhin098@gmail.com>
 License: MIT License

{agentx_dev-3.0.2 → agentx_dev-3.0.5}/agentx_dev.egg-info/top_level.txt

@@ -1,4 +1,3 @@
 agentx_dev
 dist
 examples
-test_dl

{agentx_dev-3.0.2 → agentx_dev-3.0.5}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 
 name = "agentx-dev"
-version = "3.0.2"
+version = "3.0.5"
 description = "A lightweight LLM agent framework with multi-agent orchestration (Supervisor + dynamic specialist spawning), permission-gated default tools, MCP integration, and prompt-template presets."
 authors = [{ name = "Bruce-Arhin Shadrach", email = "brucearhin098@gmail.com" }]
 # Best practice: link to the license file