mojentic 0.7.1__tar.gz → 0.7.3__tar.gz

{mojentic-0.7.1/src/mojentic.egg-info → mojentic-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.7.1
+Version: 0.7.3
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/svetzal/mojentic
@@ -30,9 +30,10 @@ Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
 Requires-Dist: flake8>=6.0.0; extra == "dev"
 Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocs-llmstxt; extra == "dev"
 Requires-Dist: mkdocstrings[python]; extra == "dev"
 Requires-Dist: griffe-fieldz; extra == "dev"
-Requires-Dist: mkdocs-material; extra == "dev"
 Requires-Dist: pymdown-extensions; extra == "dev"
 Dynamic: license-file
 

{mojentic-0.7.1 → mojentic-0.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mojentic"
-version = "0.7.1"
+version = "0.7.3"
 authors = [
     { name = "Stacey Vetzal", email = "stacey@vetzal.com" },
 ]
@@ -36,9 +36,10 @@ dev = [
     "pytest-mock>=3.10.0",
     "flake8>=6.0.0",
     "mkdocs",
+    "mkdocs-material",
+    "mkdocs-llmstxt",
     "mkdocstrings[python]",
     "griffe-fieldz",
-    "mkdocs-material",
     "pymdown-extensions",
 ]
 

{mojentic-0.7.1 → mojentic-0.7.3}/src/_examples/broker_as_tool.py

@@ -2,7 +2,7 @@ import os
 from mojentic.agents.base_llm_agent import BaseLLMAgent
 from mojentic.llm.llm_broker import LLMBroker
 from mojentic.llm.tools.date_resolver import ResolveDateTool
-from mojentic.llm.tools.file_manager import FileManager, ListFilesTool, ReadFileTool, WriteFileTool
+from mojentic.llm.tools.file_manager import FileManager, ListFilesTool, ReadFileTool, WriteFileTool, FilesystemGateway
 from mojentic.llm.tools.tool_wrapper import ToolWrapper
 
 #
@@ -15,19 +15,22 @@ temporal_specialist = BaseLLMAgent(
     behaviour="You are a historian and sociologist who focuses on sorting out temporal events, determining what happened or will happen when."
 )
 
+if not os.path.exists("local"):
+    os.mkdir("local")
+
+# Create a filesystem gateway for the local directory
+fs = FilesystemGateway(base_path="local")
+
 knowledge_specialist = BaseLLMAgent(
     llm=LLMBroker(model="llama3.3-70b-32k"),
     tools=[
-        ListFilesTool(path="local"),
-        ReadFileTool(path="local"),
-        WriteFileTool(path="local"),
+        ListFilesTool(fs),
+        ReadFileTool(fs),
+        WriteFileTool(fs),
     ],
     behaviour="You are a knowledge management agent who focuses on sorting out facts and information, able to organize elemental ideas and make connections between them. You can list files to find out where you stored information, read files to review that information, and write files to store that information for later retrieval."
 )
 
-if not os.path.exists("local"):
-    os.mkdir("local")
-
 
 
 coordinator = BaseLLMAgent(
@@ -42,14 +45,14 @@ coordinator = BaseLLMAgent(
 result = coordinator.generate_response("""
 
 I have several things I need to do this week:
-                                       
+
 - On Monday, I need to ensure that I have called Scotiabank and ordered replacement cards for my current, credit, and line of credit accounts.
 - On Wednesday, I need to drive into Toronto for work. While in Toronto I need to pick up razors. I need to make sure I see Gregg, Britney and Vikram.
 - On Thursday, I need to ensure I'm up by 7am so that I can be showered and ready for work by 9.
 - On Friday, I need to ensure that I have my laundry done and my bags packed for my trip to Ottawa.
-                                       
+
 Create me a markdown file for each day of the week, named "YYYY-MM-DD-ToDo.md" where the date is the date of that day.
 Make a list of to-do items in the markdown file, and add a section for the day's daily notes that I can fill out each day.
 """)
 
-print(result)
+print(result)

mojentic-0.7.3/src/_examples/coding_file_tool.py

@@ -0,0 +1,181 @@
+"""
+This example demonstrates the use of all the file management tools available in mojentic.
+
+It creates an IterativeProblemSolver with access to a comprehensive set of file management tools:
+- ListFilesTool: List files in the top-level directory
+- ListAllFilesTool: List all files recursively
+- ReadFileTool: Read the content of a file
+- WriteFileTool: Write content to a file
+- CreateDirectoryTool: Create a new directory
+- FindFilesByGlobTool: Find files matching a glob pattern
+- FindFilesContainingTool: Find files containing text matching a regex pattern
+- FindLinesMatchingTool: Find lines in a file matching a regex pattern
+- EditFileWithDiffTool: Edit a file by applying a diff
+
+The solver is then given a task that requires using all of these tools.
+"""
+
+import os
+from pathlib import Path
+
+from mojentic.agents.iterative_problem_solver import IterativeProblemSolver
+from mojentic.llm.gateways import OpenAIGateway
+from mojentic.llm.llm_broker import LLMBroker
+from mojentic.llm.tools.ephemeral_task_manager import EphemeralTaskList, AppendTaskTool, \
+    ClearTasksTool, CompleteTaskTool, InsertTaskAfterTool, ListTasksTool, PrependTaskTool, \
+    StartTaskTool
+from mojentic.llm.tools.file_manager import (
+    ReadFileTool, WriteFileTool, ListFilesTool, ListAllFilesTool,
+    FindFilesByGlobTool, FindFilesContainingTool, FindLinesMatchingTool,
+    EditFileWithDiffTool, CreateDirectoryTool, FilesystemGateway
+)
+
+base_dir = Path(__file__).parent.parent.parent.parent / "code-playground2"
+
+# Initialize the LLM broker
+
+api_key = os.getenv("OPENAI_API_KEY")
+gateway = OpenAIGateway(api_key)
+llm = LLMBroker(model="o4-mini", gateway=gateway)
+
+# llm = LLMBroker("qwen2.5-coder:32b")
+# llm = LLMBroker("llama3.3")
+# llm = LLMBroker(model="qwen3-128k:32b")
+
+# Create a filesystem gateway for the sandbox
+fs = FilesystemGateway(base_path=str(base_dir))
+
+task_manager = EphemeralTaskList()
+
+# Create a list of all file management tools
+tools = [
+    ReadFileTool(fs),
+    WriteFileTool(fs),
+    ListFilesTool(fs),
+    ListAllFilesTool(fs),
+    CreateDirectoryTool(fs),
+    FindFilesByGlobTool(fs),
+    FindFilesContainingTool(fs),
+    FindLinesMatchingTool(fs),
+    EditFileWithDiffTool(fs),
+    AppendTaskTool(task_manager),
+    ClearTasksTool(task_manager),
+    CompleteTaskTool(task_manager),
+    InsertTaskAfterTool(task_manager),
+    ListTasksTool(task_manager),
+    PrependTaskTool(task_manager),
+    StartTaskTool(task_manager),
+]
+
+# Create the iterative problem solver with the tools
+solver = IterativeProblemSolver(
+    llm=llm,
+    available_tools=tools,
+    max_iterations=5,
+    system_prompt="""
+# 0 - Project Identity & Context
+
+You are an expert and principled software engineer, well versed in writing Python games. You work 
+carefully and purposefully and always check your work with an eye to testability and correctness. 
+You know that every line of code you write is a liability, and you take care that every line 
+matters.
+
+# 1 - Universal Engineering Principles
+
+* **Code is communication** — optimise for the next human reader.
+* **Simple Design Heuristics** — guiding principles, not iron laws; consult the user when you 
+need to break them.
+  1. **All tests pass** — correctness is non‑negotiable.
+  2. **Reveals intent** — code should read like an explanation.
+  3. **No *****knowledge***** duplication** — avoid multiple spots that must change together; 
+  identical code is only a smell when it hides duplicate *decisions*.
+  4. **Minimal entities** — remove unnecessary indirection, classes, or parameters.
+* **Small, safe increments** — single‑reason commits; avoid speculative work (**YAGNI**).
+* **Tests are the executable spec** — red first, green always; test behaviour not implementation.
+* **Compose over inherit**; favour pure functions where practical, avoid side-effects.
+* **Functional core, imperative shell** — isolate pure business logic from I/O and side effects; 
+push mutations to the system boundaries, build mockable gateways at those boundaries.
+* **Psychological safety** — review code, not colleagues; critique ideas, not authors.
+* **Version‑control etiquette** — descriptive commit messages, branch from `main`, PRs require 
+green CI.
+
+# 2 - Python‑Specific Conventions
+
+## 2.1 Runtime & Environment
+
+* **Python ≥ 3.12** (support the two most recent LTS releases).
+* Create an isolated environment:
+
+  ```bash
+  python -m venv .venv
+  source .venv/bin/activate
+  pip install -e ".[dev]"
+  ```
+* Enforce `pre‑commit` hooks (flake8, mypy, black, pytest).
+
+## 2.2 Core Libraries
+
+Mandatory: pydantic, structlog, pytest, pytest-spec, pytest-cov, pytest-mock, flake8, black, 
+pre‑commit, mkdocs‑material. Add new libs only when they eliminate **significant** boilerplate or 
+risk.
+
+## 2.3 Project Structure & Imports
+
+* **src‑layout**: code in `src/<package_name>/`; tests live beside code as `*_spec.py`.
+* Import order: 1) stdlib, 2) third‑party, 3) first‑party — each group alphabetised with a blank 
+line.
+
+## 2.4 Naming & Style
+
+* `snake_case` for functions & vars, `PascalCase` for classes, `UPPER_SNAKE` for constants.
+* Prefix intentionally unused vars/args with `_`.
+* **flake8** (with plugins) handles linting, and **black** auto‑formats code. Max line length 
+**100**.
+* Cyclomatic complexity cap: **10** (flake8 `C901`).
+* Use **f‑strings**; avoid magic numbers.
+
+## 2.5 Type Hints & Docstrings
+
+* **100% type coverage**; code must pass `mypy --strict`.
+* Use `pydantic.BaseModel` for data models; don't use bare `@dataclass` if validation is needed.
+* Docstrings in Google format; omit the obvious.
+
+## 2.6 Logging & Observability
+
+* Configure **structlog** for JSON output by default.
+* Never use `print` for diagnostics; reserve for user‑facing CLI UX.
+* Log levels: `DEBUG` (dev detail) → `INFO` (lifecycle) → `WARNING` (recoverable) → `ERROR` (user 
+visible).
+
+## 2.7 Testing Strategy
+
+* **pytest** with **pytest-spec** for specification-style output.
+* Test files end with `_spec.py` and live in the same folder as the code under test.
+* Use **Arrange / Act / Assert** blocks separated by a blank line (no comments) **or** BDD 
+`describe/should` classes.
+* Function names: use `should_*` and BDD-style specifications.
+* Class names: use `Describe*` and BDD-style test suites.
+* **Mocking**: Use `pytest-mock`'s `mocker` fixture; don't use `unittest.mock.MagicMock` directly.
+* One behavioural expectation per test. Fixtures are helpers, not magic.
+* Tests should fail for one reason, avoid multiple assert statements, split the test cases
+
+# 3 - Planning and Goal Tracking
+
+- Use the provided task manager tools to create your plans and work through them step by step.
+- Before declaring yourself finished list all tasks, ensure they are all complete, and that you 
+have not missed any steps
+- If you've missed or forgotten some steps, add them to the task list and continue
+- When all tasks are complete, and you can think of no more to add, declare yourself finished.
+    """
+)
+
+# Define the task
+task = """
+Create a new Python project that is a graphical clone of Windows MineSweeper.
+
+Ensure it is well tested.
+"""
+
+# Solve the task and print the result
+result = solver.solve(task)
+print(result)

{mojentic-0.7.1 → mojentic-0.7.3}/src/_examples/file_tool.py

@@ -5,7 +5,7 @@ from mojentic.agents.output_agent import OutputAgent
 from mojentic.dispatcher import Dispatcher
 from mojentic.event import Event
 from mojentic.llm.llm_broker import LLMBroker
-from mojentic.llm.tools.file_manager import ReadFileTool, WriteFileTool
+from mojentic.llm.tools.file_manager import ReadFileTool, WriteFileTool, FilesystemGateway
 from mojentic.router import Router
 
 
@@ -25,8 +25,10 @@ class RequestAgent(BaseLLMAgent):
     def __init__(self, llm: LLMBroker):
         super().__init__(llm,
                          "You are a helpful assistant.")
-        self.add_tool(ReadFileTool("/tmp"))
-        self.add_tool(WriteFileTool("/tmp"))
+        # Create a filesystem gateway for the /tmp directory
+        fs = FilesystemGateway(base_path="/tmp")
+        self.add_tool(ReadFileTool(fs))
+        self.add_tool(WriteFileTool(fs))
 
     def receive_event(self, event):
         response = self.generate_response(event.text)

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/__init__.py

@@ -7,10 +7,12 @@ import logging
 
 import structlog
 
+# Core components
 from .dispatcher import Dispatcher
 from .event import Event
 from .router import Router
 
+# Initialize logging
 logging.basicConfig(level=logging.INFO)
 structlog.configure(logger_factory=structlog.stdlib.LoggerFactory(), processors=[
     structlog.stdlib.filter_by_level,
@@ -22,13 +24,6 @@ structlog.configure(logger_factory=structlog.stdlib.LoggerFactory(), processors=
 logger = structlog.get_logger()
 logger.info("Starting logger")
 
-# logger = logging.getLogger("mojentic")
-# path = Path().cwd()
-# log_filename = path / 'output.log'
-# print(f"Logging to {log_filename}")
-# logging.basicConfig(filename=log_filename, level=logging.DEBUG)
-# logger.info("Starting logger")
-
 
 __version__: str
 try:

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/agents/__init__.py

@@ -1,7 +1,16 @@
+"""
+Mojentic agents module for creating and working with various agent types.
+"""
+
+# Base agent types
 from .base_agent import BaseAgent
-from .base_llm_agent import BaseLLMAgent
-from .base_llm_agent import BaseLLMAgentWithMemory
+from .base_llm_agent import BaseLLMAgent, BaseLLMAgentWithMemory
+
+# Special purpose agents
 from .correlation_aggregator_agent import BaseAggregatingAgent
 from .output_agent import OutputAgent
 from .iterative_problem_solver import IterativeProblemSolver
 from .simple_recursive_agent import SimpleRecursiveAgent
+
+# Agent brokering
+from .agent_broker import AgentBroker

mojentic-0.7.3/src/mojentic/context/__init__.py

@@ -0,0 +1,5 @@
+"""
+Mojentic context module for managing shared working memory and context.
+"""
+
+from .shared_working_memory import SharedWorkingMemory

mojentic-0.7.3/src/mojentic/llm/__init__.py

@@ -0,0 +1,16 @@
+"""
+Mojentic LLM module for interacting with Large Language Models.
+"""
+
+# Main LLM components
+from .llm_broker import LLMBroker
+from .chat_session import ChatSession
+from .message_composers import MessageBuilder, FileTypeSensor
+from .registry.llm_registry import LLMRegistry
+
+# Re-export gateway components at the LLM level
+from .gateways.models import (
+    LLMMessage,
+    LLMGatewayResponse,
+    MessageRole
+)

mojentic-0.7.3/src/mojentic/llm/gateways/__init__.py

@@ -0,0 +1,25 @@
+"""
+Mojentic LLM gateways module for connecting to various LLM providers.
+"""
+
+# Gateway implementations
+from .llm_gateway import LLMGateway
+from .ollama import OllamaGateway
+from .openai import OpenAIGateway
+from .anthropic import AnthropicGateway
+from .file_gateway import FileGateway
+from .embeddings_gateway import EmbeddingsGateway
+from .tokenizer_gateway import TokenizerGateway
+
+# Message adapters
+from .anthropic_messages_adapter import adapt_messages_to_anthropic
+from .ollama_messages_adapter import adapt_messages_to_ollama
+from .openai_messages_adapter import adapt_messages_to_openai
+
+# Common models
+from .models import (
+    LLMMessage,
+    MessageRole,
+    LLMGatewayResponse,
+    LLMToolCall
+)

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/llm/gateways/anthropic.py

@@ -29,7 +29,7 @@ class AnthropicGateway(LLMGateway):
         response = self.client.messages.create(
             **anthropic_args,
             temperature=args.get('temperature', 1.0),
-            max_tokens=args.get('num_predict', 2000),
+            max_tokens=args.get('max_tokens', args.get('num_predict', 2000)),
             # thinking={
             #     "type": "enabled",
             #     "budget_tokens": 32768,

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/llm/gateways/llm_gateway.py

@@ -19,7 +19,7 @@ class LLMGateway:
                  object_model: Optional[Type[BaseModel]] = None,
                  tools: Optional[List[LLMTool]] = None,
                  temperature: float = 1.0,
-                 num_ctx: int = 32768,
+                 num_ctx: int = 32768, max_tokens: int = 16384,
                  num_predict: int = -1) -> LLMGatewayResponse:
         """
         Complete the LLM request.
@@ -39,6 +39,8 @@ class LLMGateway:
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int
             The number of tokens to predict. Defaults to no limit.
 

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/llm/gateways/ollama.py

@@ -35,6 +35,8 @@ class OllamaGateway(LLMGateway):
         )
         if args.get('num_predict', 0) > 0:
             options.num_predict = args['num_predict']
+        if 'max_tokens' in args:
+            options.num_predict = args['max_tokens']
         return options
 
     def complete(self, **args) -> LLMGatewayResponse:
@@ -56,6 +58,8 @@ class OllamaGateway(LLMGateway):
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int, optional
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int, optional
             The number of tokens to predict. Defaults to no limit.
 
@@ -120,6 +124,8 @@ class OllamaGateway(LLMGateway):
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int, optional
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int, optional
             The number of tokens to predict. Defaults to no limit.
 

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/llm/gateways/openai.py

@@ -46,6 +46,8 @@ class OpenAIGateway(LLMGateway):
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int, optional
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int, optional
             The number of tokens to predict. Defaults to no limit.
 
@@ -68,6 +70,9 @@ class OpenAIGateway(LLMGateway):
         if 'tools' in args and args['tools'] is not None:
             openai_args['tools'] = [t.descriptor for t in args['tools']]
 
+        if 'max_tokens' in args:
+            openai_args['max_tokens'] = args['max_tokens']
+
         response = completion(**openai_args)
 
         object = None

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/llm/llm_broker.py

@@ -5,18 +5,19 @@ from typing import List, Optional, Type
 import structlog
 from pydantic import BaseModel
 
-from mojentic.tracer.tracer_system import TracerSystem
 from mojentic.llm.gateways.llm_gateway import LLMGateway
 from mojentic.llm.gateways.models import MessageRole, LLMMessage, LLMGatewayResponse
 from mojentic.llm.gateways.ollama import OllamaGateway
 from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
+from mojentic.tracer.tracer_system import TracerSystem
 
 logger = structlog.get_logger()
 
 
 class LLMBroker():
     """
-    This class is responsible for managing interaction with a Large Language Model. It abstracts the user
+    This class is responsible for managing interaction with a Large Language Model. It abstracts
+    the user
     from the specific mechanics of the LLM and provides a common interface for generating responses.
     """
 
@@ -25,7 +26,8 @@ class LLMBroker():
     model: str
     tracer: Optional[TracerSystem]
 
-    def __init__(self, model: str, gateway: Optional[LLMGateway] = None, tokenizer: Optional[TokenizerGateway] = None,
+    def __init__(self, model: str, gateway: Optional[LLMGateway] = None,
+                 tokenizer: Optional[TokenizerGateway] = None,
                  tracer: Optional[TracerSystem] = None):
         """
         Create an instance of the LLMBroker.
@@ -35,10 +37,12 @@ class LLMBroker():
         model
             The name of the model to use.
         gateway
-            The gateway to use for communication with the LLM. If None, a gateway is created that will utilize a local
+            The gateway to use for communication with the LLM. If None, a gateway is created that
+            will utilize a local
             Ollama server.
         tokenizer
-            The gateway to use for tokenization. This is used to log approximate token counts for the LLM calls. If
+            The gateway to use for tokenization. This is used to log approximate token counts for
+            the LLM calls. If
             None, `mxbai-embed-large` is used on a local Ollama server.
         tracer
             Optional tracer system to record LLM calls and responses.
@@ -58,8 +62,9 @@ class LLMBroker():
         else:
             self.adapter = gateway
 
-    def generate(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768, num_predict=-1, 
-              correlation_id: str = None) -> str:
+    def generate(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768,
+                 num_predict=-1, max_tokens=16384,
+                 correlation_id: str = None) -> str:
         """
         Generate a text response from the LLM.
 
@@ -68,7 +73,8 @@ class LLMBroker():
         messages : LLMMessage
             A list of messages to send to the LLM.
         tools : List[Tool]
-            A list of tools to use with the LLM. If a tool call is requested, the tool will be called and the output
+            A list of tools to use with the LLM. If a tool call is requested, the tool will be
+            called and the output
             will be included in the response.
         temperature : float
             The temperature to use for the response. Defaults to 1.0
@@ -91,10 +97,11 @@ class LLMBroker():
         messages_for_tracer = [m.model_dump() for m in messages]
 
         # Record LLM call in tracer
-        tools_for_tracer = [{"name": t.name, "description": t.description} for t in tools] if tools else None
+        tools_for_tracer = [{"name": t.name, "description": t.description} for t in
+                            tools] if tools else None
         self.tracer.record_llm_call(
-            self.model, 
-            messages_for_tracer, 
+            self.model,
+            messages_for_tracer,
             temperature,
             tools=tools_for_tracer,
             source=type(self),
@@ -110,12 +117,14 @@ class LLMBroker():
             tools=tools,
             temperature=temperature,
             num_ctx=num_ctx,
-            num_predict=num_predict)
+            num_predict=num_predict,
+            max_tokens=max_tokens)
 
         call_duration_ms = (time.time() - start_time) * 1000
 
         # Record LLM response in tracer
-        tool_calls_for_tracer = [tc.model_dump() for tc in result.tool_calls] if result.tool_calls else None
+        tool_calls_for_tracer = [tc.model_dump() for tc in
+                                 result.tool_calls] if result.tool_calls else None
         self.tracer.record_llm_response(
             self.model,
             result.content,
@@ -153,13 +162,17 @@ class LLMBroker():
                     logger.info('Function output', output=output)
                     messages.append(LLMMessage(role=MessageRole.Assistant, tool_calls=[tool_call]))
                     messages.append(
-                        LLMMessage(role=MessageRole.Tool, content=json.dumps(output), tool_calls=[tool_call]))
-                    # {'role': 'tool', 'content': str(output), 'name': tool_call.name, 'tool_call_id': tool_call.id})
-                    return self.generate(messages, tools, temperature, num_ctx, num_predict, correlation_id=correlation_id)
+                        LLMMessage(role=MessageRole.Tool, content=json.dumps(output),
+                                   tool_calls=[tool_call]))
+                    # {'role': 'tool', 'content': str(output), 'name': tool_call.name,
+                    # 'tool_call_id': tool_call.id})
+                    return self.generate(messages, tools, temperature, num_ctx, num_predict,
+                                         correlation_id=correlation_id)
                 else:
                     logger.warn('Function not found', function=tool_call.name)
                     logger.info('Expected usage of missing function', expected_usage=tool_call)
-                    # raise Exception('Unknown tool function requested:', requested_tool.function.name)
+                    # raise Exception('Unknown tool function requested:',
+                    # requested_tool.function.name)
 
         return result.content
 
@@ -170,8 +183,9 @@ class LLMBroker():
                 content += message.content
         return content
 
-    def generate_object(self, messages: List[LLMMessage], object_model: Type[BaseModel], temperature=1.0, num_ctx=32768,
-                        num_predict=-1, correlation_id: str = None) -> BaseModel:
+    def generate_object(self, messages: List[LLMMessage], object_model: Type[BaseModel],
+                        temperature=1.0, num_ctx=32768, num_predict=-1, max_tokens=16384,
+                        correlation_id: str = None) -> BaseModel:
         """
         Generate a structured response from the LLM and return it as an object.
 
@@ -203,8 +217,8 @@ class LLMBroker():
 
         # Record LLM call in tracer
         self.tracer.record_llm_call(
-            self.model, 
-            messages_for_tracer, 
+            self.model,
+            messages_for_tracer,
             temperature,
             tools=None,
             source=type(self),
@@ -214,14 +228,18 @@ class LLMBroker():
         # Measure call duration for audit
         start_time = time.time()
 
-        result = self.adapter.complete(model=self.model, messages=messages, object_model=object_model,
-                                       temperature=temperature, num_ctx=num_ctx, num_predict=num_predict)
+        result = self.adapter.complete(model=self.model, messages=messages,
+                                       object_model=object_model,
+                                       temperature=temperature, num_ctx=num_ctx,
+                                       num_predict=num_predict, max_tokens=max_tokens)
 
         call_duration_ms = (time.time() - start_time) * 1000
 
         # Record LLM response in tracer with object representation
         # Convert object to string for tracer
-        object_str = str(result.object.model_dump()) if hasattr(result.object, "model_dump") else str(result.object)
+        object_str = str(result.object.model_dump()) if hasattr(result.object,
+                                                                "model_dump") else str(
+            result.object)
         self.tracer.record_llm_response(
             self.model,
             f"Structured response: {object_str}",

{mojentic-0.7.1 → mojentic-0.7.3}/src/mojentic/llm/message_composers.py

@@ -216,7 +216,7 @@ class MessageBuilder():
 
         return self
 
-    def add_files(self, *file_paths: Union[str, Path]) -> "MessageBuilder":
+    def add_files(self, *file_paths: List[Union[str, Path]]) -> "MessageBuilder":
         """
         Add multiple text files to the message, ignoring binary files.
 

mojentic-0.7.3/src/mojentic/llm/registry/__init__.py

@@ -0,0 +1,6 @@
+"""
+Mojentic LLM registry module for managing model registrations.
+"""
+
+from .llm_registry import LLMRegistry
+from .models import ModelInfo, Modality, Quantization