nvidia-nat 1.4.0a20251102__py3-none-any.whl → 1.4.0a20251112__py3-none-any.whl

nat/cli/commands/workflow/workflow_commands.py

@@ -354,7 +354,8 @@ def reinstall_command(workflow_name):
 
 @click.command()
 @click.argument('workflow_name')
-def delete_command(workflow_name: str):
+@click.option('-y', '--yes', "yes_flag", is_flag=True, default=False, help='Do not prompt for confirmation.')
+def delete_command(workflow_name: str, yes_flag: bool):
     """
     Delete a NAT workflow and uninstall its package.
 
@@ -362,7 +363,7 @@ def delete_command(workflow_name: str):
         workflow_name (str): The name of the workflow to delete.
     """
     try:
-        if not click.confirm(f"Are you sure you want to delete the workflow '{workflow_name}'?"):
+        if not yes_flag and not click.confirm(f"Are you sure you want to delete the workflow '{workflow_name}'?"):
             click.echo("Workflow deletion cancelled.")
             return
         editable = get_repo_root() is not None

nat/eval/dataset_handler/dataset_filter.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import fnmatch
+
 import pandas as pd
 
 from nat.data_models.dataset_handler import EvalFilterConfig
@@ -24,6 +26,7 @@ class DatasetFilter:
         - If a allowlist is provided, only keep rows matching the filter values.
         - If a denylist is provided, remove rows matching the filter values.
         - If the filter column does not exist in the DataFrame, the filtering is skipped for that column.
+        - Supports Unix shell-style wildcards (``*``, ``?``, ``[seq]``, ``[!seq]``) for string matching.
 
     This is a utility class that is dataset agnostic and can be used to filter any DataFrame based on the provided
     filter configuration.
@@ -33,6 +36,33 @@ class DatasetFilter:
 
         self.filter_config = filter_config
 
+    @staticmethod
+    def _match_wildcard_patterns(series: pd.Series, patterns: list[str | int | float]) -> pd.Series:
+        """
+        Match series values against wildcard patterns and exact values.
+
+        Args:
+            series (pd.Series): pandas Series to match against
+            patterns (list[str | int | float]): List of patterns/values
+
+        Returns:
+            pd.Series: Boolean Series indicating matches
+        """
+        # Convert series to string for pattern matching
+        str_series = series.astype(str)
+
+        # Initialize boolean mask
+        matches = pd.Series([False] * len(series), index=series.index)
+
+        # Check each pattern using fnmatch with list comprehension to avoid lambda capture
+        for pattern in patterns:
+            pattern_str = str(pattern)
+            pattern_matches = pd.Series([fnmatch.fnmatch(val, pattern_str) for val in str_series],
+                                        index=str_series.index)
+            matches |= pattern_matches
+
+        return matches
+
     def apply_filters(self, df) -> pd.DataFrame:
 
         filtered_df = df.copy()
@@ -41,12 +71,14 @@ class DatasetFilter:
         if self.filter_config.allowlist:
             for column, values in self.filter_config.allowlist.field.items():
                 if column in filtered_df.columns:
-                    filtered_df = filtered_df[filtered_df[column].isin(values)]
+                    matches = self._match_wildcard_patterns(filtered_df[column], values)
+                    filtered_df = filtered_df[matches]
 
         # Apply denylist (remove specified rows)
         if self.filter_config.denylist:
             for column, values in self.filter_config.denylist.field.items():
                 if column in filtered_df.columns:
-                    filtered_df = filtered_df[~filtered_df[column].isin(values)]
+                    matches = self._match_wildcard_patterns(filtered_df[column], values)
+                    filtered_df = filtered_df[~matches]
 
         return filtered_df

nat/eval/evaluate.py

@@ -514,7 +514,7 @@ class EvaluationRun:
         # Run workflow and evaluate
         async with WorkflowEvalBuilder.from_config(config=config) as eval_workflow:
             # Initialize Weave integration
-            self.weave_eval.initialize_logger(workflow_alias, self.eval_input, config)
+            self.weave_eval.initialize_logger(workflow_alias, self.eval_input, config, job_id=job_id)
 
             with self.eval_trace_context.evaluation_context():
                 # Run workflow

nat/eval/utils/weave_eval.py

@@ -82,7 +82,7 @@ class WeaveEvaluationIntegration:
         """Get the full dataset for Weave."""
         return [item.full_dataset_entry for item in eval_input.eval_input_items]
 
-    def initialize_logger(self, workflow_alias: str, eval_input: EvalInput, config: Any):
+    def initialize_logger(self, workflow_alias: str, eval_input: EvalInput, config: Any, job_id: str | None = None):
         """Initialize the Weave evaluation logger."""
         if not self.client and not self.initialize_client():
             # lazy init the client
@@ -92,10 +92,16 @@ class WeaveEvaluationIntegration:
             weave_dataset = self._get_weave_dataset(eval_input)
             config_dict = config.model_dump(mode="json")
             config_dict["name"] = workflow_alias
+
+            # Include job_id in eval_attributes if provided
+            eval_attributes = {}
+            if job_id:
+                eval_attributes["job_id"] = job_id
+
             self.eval_logger = self.evaluation_logger_cls(model=config_dict,
                                                           dataset=weave_dataset,
                                                           name=workflow_alias,
-                                                          eval_attributes={})
+                                                          eval_attributes=eval_attributes)
             self.pred_loggers = {}
 
             # Capture the current evaluation call for context propagation
@@ -136,9 +142,17 @@ class WeaveEvaluationIntegration:
         coros = []
         for eval_output_item in eval_output.eval_output_items:
             if eval_output_item.id in self.pred_loggers:
+                # Structure the score as a dict and include reasoning if available
+                score_value = {
+                    "score": eval_output_item.score,
+                }
+
+                if eval_output_item.reasoning is not None:
+                    score_value["reasoning"] = eval_output_item.reasoning
+
                 coros.append(self.pred_loggers[eval_output_item.id].alog_score(
                     scorer=evaluator_name,
-                    score=eval_output_item.score,
+                    score=score_value,
                 ))
 
         # Execute all coroutines concurrently

nat/front_ends/fastapi/fastapi_front_end_config.py

@@ -211,6 +211,13 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
             "Maximum number of async jobs to run concurrently, this controls the number of dask workers created. "
             "This parameter is only used when scheduler_address is `None` and a Dask local cluster is created."),
         ge=1)
+    dask_workers: typing.Literal["threads", "processes"] = Field(
+        default="processes",
+        description=(
+            "Type of Dask workers to use. Options are 'threads' for Threaded Dask workers or 'processes' for "
+            "Process based Dask workers. This parameter is only used when scheduler_address is `None` and a local Dask "
+            "cluster is created."),
+    )
     dask_log_level: str = Field(
         default="WARNING",
         description="Logging level for Dask.",

nat/front_ends/fastapi/fastapi_front_end_plugin.py

@@ -120,18 +120,24 @@ class FastApiFrontEndPlugin(DaskClientMixin, FrontEndBase[FastApiFrontEndConfig]
 
                     from dask.distributed import LocalCluster
 
-                    self._cluster = LocalCluster(processes=True,
+                    use_threads = self.front_end_config.dask_workers == 'threads'
+
+                    # set n_workers to max_running_async_jobs + 1 to allow for one worker to handle the cleanup task
+                    self._cluster = LocalCluster(processes=not use_threads,
                                                  silence_logs=dask_log_level,
-                                                 n_workers=self.front_end_config.max_running_async_jobs,
-                                                 threads_per_worker=1)
+                                                 protocol="tcp",
+                                                 n_workers=self.front_end_config.max_running_async_jobs + 1)
 
                     self._scheduler_address = self._cluster.scheduler.address
 
-                    with self.blocking_client(self._scheduler_address) as client:
-                        # Client.run submits a function to be run on each worker
-                        client.run(self._setup_worker)
+                    if not use_threads and sys.platform != "win32":
+                        with self.blocking_client(self._scheduler_address) as client:
+                            # Client.run submits a function to be run on each worker
+                            client.run(self._setup_worker)
 
-                    logger.info("Created local Dask cluster with scheduler at %s", self._scheduler_address)
+                    logger.info("Created local Dask cluster with scheduler at %s using %s workers",
+                                self._scheduler_address,
+                                self.front_end_config.dask_workers)
 
                 except ImportError:
                     logger.warning("Dask is not installed, async execution and evaluation will not be available.")

nat/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -544,7 +544,8 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
         GenerateStreamResponseType = workflow.streaming_output_schema
         GenerateSingleResponseType = workflow.single_output_schema
 
-        if self._dask_available:
+        # Skip async generation for custom routes (those with function_name)
+        if self._dask_available and not hasattr(endpoint, 'function_name'):
             # Append job_id and expiry_seconds to the input schema, this effectively makes these reserved keywords
             # Consider prefixing these with "nat_" to avoid conflicts
 
@@ -562,6 +563,10 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                                             description="Optional time (in seconds) before the job expires. "
                                             "Clamped between 600 (10 min) and 86400 (24h).")
 
+                def validate_model(self):
+                    # Override to ensure that the parent class validator is not called
+                    return self
+
         # Ensure that the input is in the body. POD types are treated as query parameters
         if (not issubclass(GenerateBodyType, BaseModel)):
             GenerateBodyType = typing.Annotated[GenerateBodyType, Body()]
@@ -760,17 +765,18 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                             return AsyncGenerateResponse(job_id=job.job_id, status=job.status)
 
                     job_id = self._job_store.ensure_job_id(request.job_id)
-                    (_, job) = await self._job_store.submit_job(job_id=job_id,
-                                                                expiry_seconds=request.expiry_seconds,
-                                                                job_fn=run_generation,
-                                                                sync_timeout=request.sync_timeout,
-                                                                job_args=[
-                                                                    self._scheduler_address,
-                                                                    self._db_url,
-                                                                    self._config_file_path,
-                                                                    job_id,
-                                                                    request.model_dump(mode="json")
-                                                                ])
+                    (_, job) = await self._job_store.submit_job(
+                        job_id=job_id,
+                        expiry_seconds=request.expiry_seconds,
+                        job_fn=run_generation,
+                        sync_timeout=request.sync_timeout,
+                        job_args=[
+                            self._scheduler_address,
+                            self._db_url,
+                            self._config_file_path,
+                            job_id,
+                            request.model_dump(mode="json", exclude=["job_id", "sync_timeout", "expiry_seconds"])
+                        ])
 
                     if job is not None:
                         response.status_code = 200
@@ -916,7 +922,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                     responses={500: response_500},
                 )
 
-                if self._dask_available:
+                if self._dask_available and not hasattr(endpoint, 'function_name'):
                     app.add_api_route(
                         path=f"{endpoint.path}/async",
                         endpoint=post_async_generation(request_type=AsyncGenerateRequest),
@@ -930,7 +936,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
             else:
                 raise ValueError(f"Unsupported method {endpoint.method}")
 
-            if self._dask_available:
+            if self._dask_available and not hasattr(endpoint, 'function_name'):
                 app.add_api_route(
                     path=f"{endpoint.path}/async/job/{{job_id}}",
                     endpoint=get_async_job_status,

nat/llm/aws_bedrock_llm.py

@@ -25,18 +25,10 @@ from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
 from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
-class AWSBedrockModelConfig(LLMBaseConfig,
-                            RetryMixin,
-                            OptimizableMixin,
-                            TemperatureMixin,
-                            TopPMixin,
-                            ThinkingMixin,
-                            name="aws_bedrock"):
+class AWSBedrockModelConfig(LLMBaseConfig, RetryMixin, OptimizableMixin, ThinkingMixin, name="aws_bedrock"):
     """An AWS Bedrock llm provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -61,6 +53,16 @@ class AWSBedrockModelConfig(LLMBaseConfig,
         default=None, description="Bedrock endpoint to use. Needed if you don't want to default to us-east-1 endpoint.")
     credentials_profile_name: str | None = Field(
         default=None, description="The name of the profile in the ~/.aws/credentials or ~/.aws/config files.")
+    temperature: float | None = OptimizableField(
+        default=None,
+        ge=0.0,
+        description="Sampling temperature to control randomness in the output.",
+        space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=AWSBedrockModelConfig)

nat/llm/azure_openai_llm.py

@@ -22,17 +22,15 @@ from nat.builder.llm import LLMProviderInfo
 from nat.cli.register_workflow import register_llm_provider
 from nat.data_models.common import OptionalSecretStr
 from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.optimizable import OptimizableField
+from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
 class AzureOpenAIModelConfig(
         LLMBaseConfig,
         RetryMixin,
-        TemperatureMixin,
-        TopPMixin,
         ThinkingMixin,
         name="azure_openai",
 ):
@@ -50,6 +48,16 @@ class AzureOpenAIModelConfig(
                                   serialization_alias="azure_deployment",
                                   description="The Azure OpenAI hosted model/deployment name.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
+    temperature: float | None = OptimizableField(
+        default=None,
+        ge=0.0,
+        description="Sampling temperature to control randomness in the output.",
+        space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=AzureOpenAIModelConfig)

nat/llm/litellm_llm.py

@@ -26,18 +26,15 @@ from nat.data_models.common import OptionalSecretStr
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
 class LiteLlmModelConfig(
         LLMBaseConfig,
         OptimizableMixin,
         RetryMixin,
-        TemperatureMixin,
-        TopPMixin,
         ThinkingMixin,
         name="litellm",
 ):
@@ -54,6 +51,16 @@ class LiteLlmModelConfig(
                                        serialization_alias="model",
                                        description="The LiteLlm hosted model name.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
+    temperature: float | None = OptimizableField(
+        default=None,
+        ge=0.0,
+        description="Sampling temperature to control randomness in the output.",
+        space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=LiteLlmModelConfig)

nat/llm/nim_llm.py

@@ -27,18 +27,10 @@ from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
 from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
-class NIMModelConfig(LLMBaseConfig,
-                     RetryMixin,
-                     OptimizableMixin,
-                     TemperatureMixin,
-                     TopPMixin,
-                     ThinkingMixin,
-                     name="nim"):
+class NIMModelConfig(LLMBaseConfig, RetryMixin, OptimizableMixin, ThinkingMixin, name="nim"):
     """An NVIDIA Inference Microservice (NIM) llm provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -51,6 +43,16 @@ class NIMModelConfig(LLMBaseConfig,
     max_tokens: PositiveInt = OptimizableField(default=300,
                                                description="Maximum number of tokens to generate.",
                                                space=SearchSpace(high=2176, low=128, step=512))
+    temperature: float | None = OptimizableField(
+        default=None,
+        ge=0.0,
+        description="Sampling temperature to control randomness in the output.",
+        space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=NIMModelConfig)

nat/llm/openai_llm.py

@@ -24,19 +24,12 @@ from nat.data_models.common import OptionalSecretStr
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
-class OpenAIModelConfig(LLMBaseConfig,
-                        RetryMixin,
-                        OptimizableMixin,
-                        TemperatureMixin,
-                        TopPMixin,
-                        ThinkingMixin,
-                        name="openai"):
+class OpenAIModelConfig(LLMBaseConfig, RetryMixin, OptimizableMixin, ThinkingMixin, name="openai"):
     """An OpenAI LLM provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -48,6 +41,16 @@ class OpenAIModelConfig(LLMBaseConfig,
                                        description="The OpenAI hosted model name.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
     max_retries: int = Field(default=10, description="The max number of retries for the request.")
+    temperature: float | None = OptimizableField(
+        default=None,
+        ge=0.0,
+        description="Sampling temperature to control randomness in the output.",
+        space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=OpenAIModelConfig)

nat/tool/code_execution/code_sandbox.py

@@ -92,7 +92,9 @@ class Sandbox(abc.ABC):
             raise ValueError(f"Language {language} not supported")
 
         generated_code = generated_code.strip().strip("`")
-        code_to_execute = textwrap.dedent("""
+        # Use json.dumps to properly escape the generated_code instead of repr()
+        escaped_code = json.dumps(generated_code)
+        code_to_execute = textwrap.dedent(f"""
             import traceback
             import json
             import os
@@ -101,11 +103,6 @@ class Sandbox(abc.ABC):
             import io
             warnings.filterwarnings('ignore')
             os.environ['OPENBLAS_NUM_THREADS'] = '16'
-        """).strip()
-
-        # Use json.dumps to properly escape the generated_code instead of repr()
-        escaped_code = json.dumps(generated_code)
-        code_to_execute += textwrap.dedent(f"""
 
             generated_code = {escaped_code}
 

nat/tool/code_execution/local_sandbox/Dockerfile.sandbox

@@ -12,43 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Use the base image with Python 3.10 and Flask
-FROM tiangolo/uwsgi-nginx-flask:python3.10
-
-# Install dependencies required for Lean 4 and other tools
-RUN apt-get update && \
-    apt-get install -y curl git && \
-    curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh -s -- -y && \
-    /root/.elan/bin/elan toolchain install leanprover/lean4:v4.12.0 && \
-    /root/.elan/bin/elan default leanprover/lean4:v4.12.0 && \
-    /root/.elan/bin/elan self update
-
-# Set environment variables to include Lean and elan/lake in the PATH
-ENV PATH="/root/.elan/bin:$PATH"
-
-# Create Lean project directory and initialize a new Lean project with Mathlib4
-RUN mkdir -p /lean4 && cd /lean4 && \
-    /root/.elan/bin/lake new my_project && \
-    cd my_project && \
-    echo 'leanprover/lean4:v4.12.0' > lean-toolchain && \
-    echo 'require mathlib from git "https://github.com/leanprover-community/mathlib4" @ "v4.12.0"' >> lakefile.lean
-
-# Download and cache Mathlib4 to avoid recompiling, then build the project
-RUN cd /lean4/my_project && \
-    /root/.elan/bin/lake exe cache get && \
-    /root/.elan/bin/lake build
-
-# Set environment variables to include Lean project path
-ENV LEAN_PATH="/lean4/my_project"
-ENV PATH="/lean4/my_project:$PATH"
+# UWSGI_CHEAPER sets the number of initial uWSGI worker processes
+# UWSGI_PROCESSES sets the maximum number of uWSGI worker processes
+ARG UWSGI_CHEAPER=5
+ARG UWSGI_PROCESSES=10
+
+# Use the base image with Python 3.13
+FROM python:3.13-slim-bookworm
+
+
+RUN apt update && \
+    apt upgrade && \
+    apt install -y --no-install-recommends libexpat1 && \
+    apt clean && \
+    rm -rf /var/lib/apt/lists/*
 
 # Set up application code and install Python dependencies
 COPY sandbox.requirements.txt /app/requirements.txt
 RUN pip install --no-cache-dir -r /app/requirements.txt
 COPY local_sandbox_server.py /app/main.py
-
-# Set the working directory to /app
-WORKDIR /app
+RUN mkdir /workspace
 
 # Set Flask app environment variables and ports
 ARG UWSGI_CHEAPER
@@ -58,3 +41,7 @@ ARG UWSGI_PROCESSES
 ENV UWSGI_PROCESSES=$UWSGI_PROCESSES
 
 ENV LISTEN_PORT=6000
+EXPOSE 6000
+
+WORKDIR /app
+CMD uwsgi --http 0.0.0.0:${LISTEN_PORT} --master -p ${UWSGI_PROCESSES} --force-cwd /workspace -w main:app

nat/tool/code_execution/local_sandbox/local_sandbox_server.py

@@ -194,5 +194,10 @@ def execute():
     return do_execute(request)
 
 
+@app.route("/", methods=["GET"])
+def status() -> tuple[dict[str, str], int]:
+    return ({"status": "ok"}, 200)
+
+
 if __name__ == '__main__':
     app.run(port=6000)

nat/tool/code_execution/local_sandbox/sandbox.requirements.txt

@@ -1,6 +1,8 @@
+Flask==3.1
 numpy
 pandas
 scipy
 ipython
 plotly
 pydantic
+pyuwsgi==2.0.*

nat/tool/code_execution/local_sandbox/start_local_sandbox.sh

@@ -19,7 +19,11 @@
 
 DOCKER_COMMAND=${DOCKER_COMMAND:-"docker"}
 SANDBOX_NAME=${1:-'local-sandbox'}
-NUM_THREADS=10
+
+# UWSGI_CHEAPER sets the number of initial uWSGI worker processes
+# UWSGI_PROCESSES sets the maximum number of uWSGI worker processes
+UWSGI_CHEAPER=${UWSGI_CHEAPER:-5}
+UWSGI_PROCESSES=${UWSGI_PROCESSES:-10}
 
 # Get the output_data directory path for mounting
 # Priority: command line argument > environment variable > default path (current directory)
@@ -37,14 +41,16 @@ fi
 # Check if the Docker image already exists
 if ! ${DOCKER_COMMAND} images ${SANDBOX_NAME} | grep -q "${SANDBOX_NAME}"; then
     echo "Docker image not found locally. Building ${SANDBOX_NAME}..."
-    ${DOCKER_COMMAND} build --tag=${SANDBOX_NAME} --build-arg="UWSGI_PROCESSES=$((${NUM_THREADS} * 10))" --build-arg="UWSGI_CHEAPER=${NUM_THREADS}" -f Dockerfile.sandbox .
+    ${DOCKER_COMMAND} build --tag=${SANDBOX_NAME} \
+        --build-arg="UWSGI_PROCESSES=${UWSGI_PROCESSES}" \
+        --build-arg="UWSGI_CHEAPER=${UWSGI_CHEAPER}" \
+        -f Dockerfile.sandbox .
 else
     echo "Using existing Docker image: ${SANDBOX_NAME}"
 fi
 
 # Mount the output_data directory directly so files created in container appear in the local directory
-${DOCKER_COMMAND} run --rm --name=local-sandbox \
+${DOCKER_COMMAND} run --rm -ti --name=local-sandbox \
   --network=host \
   -v "${OUTPUT_DATA_PATH}:/workspace" \
-  -w /workspace \
   ${SANDBOX_NAME}

nat/tool/server_tools.py

@@ -32,14 +32,23 @@ class RequestAttributesTool(FunctionBaseConfig, name="current_request_attributes
 @register_function(config_type=RequestAttributesTool)
 async def current_request_attributes(config: RequestAttributesTool, builder: Builder):
 
+    from pydantic import RootModel
+    from pydantic.types import JsonValue
     from starlette.datastructures import Headers
     from starlette.datastructures import QueryParams
 
-    async def _get_request_attributes(unused: str) -> str:
+    class RequestBody(RootModel[JsonValue]):
+        """
+        Data model that accepts a request body of any valid JSON type.
+        """
+        root: JsonValue
+
+    async def _get_request_attributes(request_body: RequestBody) -> str:
 
         from nat.builder.context import Context
         nat_context = Context.get()
 
+        # Access request attributes from context
         method: str | None = nat_context.metadata.method
         url_path: str | None = nat_context.metadata.url_path
         url_scheme: str | None = nat_context.metadata.url_scheme
@@ -51,6 +60,9 @@ async def current_request_attributes(config: RequestAttributesTool, builder: Bui
         cookies: dict[str, str] | None = nat_context.metadata.cookies
         conversation_id: str | None = nat_context.conversation_id
 
+        # Access the request body data - can be any valid JSON type
+        request_body_data: JsonValue = request_body.root
+
         return (f"Method: {method}, "
                 f"URL Path: {url_path}, "
                 f"URL Scheme: {url_scheme}, "
@@ -60,7 +72,8 @@ async def current_request_attributes(config: RequestAttributesTool, builder: Bui
                 f"Client Host: {client_host}, "
                 f"Client Port: {client_port}, "
                 f"Cookies: {cookies}, "
-                f"Conversation Id: {conversation_id}")
+                f"Conversation Id: {conversation_id}, "
+                f"Request Body: {request_body_data}")
 
     yield FunctionInfo.from_fn(_get_request_attributes,
                                description="Returns the acquired user defined request attributes.")