soliplex 0.77.2__tar.gz → 0.78__tar.gz

{soliplex-0.77.2/src/soliplex.egg-info → soliplex-0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.77.2
+Version: 0.78
 Summary: An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface.
 Author-email: Enfold <info@enfoldsystems.net>
 Classifier: Programming Language :: Python :: 3

{soliplex-0.77.2 → soliplex-0.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.77.2"
+version = "0.78"
 description = "An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface."
 authors = [{ name = "Enfold", email = "info@enfoldsystems.net" }]
 readme = "README.md"

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/agents.py

@@ -144,18 +144,11 @@ def get_default_agent_from_configs(
         if isinstance(capability, HR_VisionCapabilities):
             capability.vision = agent_config.multimodal
 
-    # A single model-facing capability loads eagerly so its tools are visible;
-    #
-    # Multiple stay deferred so the model routes between them via
-    # 'load_capability'.
-    routing_capabilities = [
-        capability
-        for capability in capabilities
-        if _is_routing_capability(capability)
-    ]
-    defer_loading = len(routing_capabilities) > 1
-    for capability in routing_capabilities:
-        capability.defer_loading = defer_loading
+    # A hook-only capability is never deferred:  nothing would load it, and
+    # its hooks only fire once loaded.
+    for capability in capabilities:
+        if not _is_routing_capability(capability):
+            capability.defer_loading = False
 
     return pydantic_ai.Agent(
         model=model,

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/config/agents.py

@@ -271,6 +271,16 @@ class AgentConfig:
         else:  # pragma: NO COVER
             pass
 
+    @property
+    def llm_model_name(self) -> str | None:
+        model_name = self.model_name
+        i_config = self._installation_config
+
+        if i_config is not None:
+            model_name = i_config.interpolate_environment(model_name)
+
+        return model_name
+
     @property
     def llm_provider_base_url(self) -> str | None:
         ic = self._installation_config
@@ -324,7 +334,7 @@ class AgentConfig:
         return {
             "id": self.id,
             "kind": self.kind,
-            "model_name": self.model_name,
+            "model_name": self.model_name,  # not interpolated
             "retries": self.retries,
             "system_prompt": prompt,
             "model_settings": self.model_settings,
@@ -478,6 +488,7 @@ def get_model_from_config(
     provider_kw = agent_config.llm_provider_kw
 
     model_settings_kw = {}
+    model_name = agent_config.llm_model_name
 
     if agent_config.model_settings:
         model_settings_kw["settings"] = ai_settings.ModelSettings(
@@ -487,7 +498,7 @@ def get_model_from_config(
     if agent_config.provider_type == LLMProviderType.GOOGLE:
         provider = google_providers.GoogleProvider(**provider_kw)
         return google_models.GoogleModel(
-            model_name=agent_config.model_name,
+            model_name=model_name,
             provider=provider,
             **model_settings_kw,
         )
@@ -496,7 +507,7 @@ def get_model_from_config(
         provider_kw["api_key"] = "dummy"
         provider = ollama_providers.OllamaProvider(**provider_kw)
         return openai_models.OpenAIChatModel(
-            model_name=agent_config.model_name,
+            model_name=model_name,
             provider=provider,
             profile=_OPENAI_COMPAT_PROFILE,
             **model_settings_kw,
@@ -510,7 +521,7 @@ def get_model_from_config(
         )
         provider = openai_providers.OpenAIProvider(**provider_kw)
         return openai_models.OpenAIChatModel(
-            model_name=agent_config.model_name,
+            model_name=model_name,
             provider=provider,
             **profile_kw,
             **model_settings_kw,

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/config/skills.py

@@ -179,6 +179,22 @@ class FilesystemSkillConfig:
     def extra_parameters(self) -> dict[str, pathlib.Path]:
         return {"path": self.path}
 
+    def with_defer_loading(self, defer_loading: bool) -> FilesystemSkillConfig:
+        """A copy whose capability loads as a room asked.
+
+        Installation skill configs are shared between the rooms which name
+        them, so a room's choice cannot be written onto the capability.
+        """
+        if defer_loading == self._capability.defer_loading:
+            return self
+        return dataclasses.replace(
+            self,
+            _capability=dataclasses.replace(
+                self._capability,
+                defer_loading=defer_loading,
+            ),
+        )
+
 
 @dataclasses.dataclass(kw_only=True)
 class _HaikuRAGCapabilityConfig(
@@ -192,6 +208,8 @@ class _HaikuRAGCapabilityConfig(
     state_type: typing.ClassVar[type[pydantic.BaseModel]]
     source: typing.ClassVar[SkillKind] = SkillKind.NATIVE
 
+    defer_loading: bool = False
+
     @classmethod
     def from_yaml(
         cls,
@@ -230,7 +248,7 @@ class _HaikuRAGCapabilityConfig(
         return type(self).capability_factory(
             db_path=self.rag_lancedb_path,
             config=self.haiku_rag_config,
-            defer_loading=True,
+            defer_loading=self.defer_loading,
         )
 
     @property
@@ -239,7 +257,10 @@ class _HaikuRAGCapabilityConfig(
 
     @property
     def as_yaml(self) -> dict:
-        result = {"kind": self.kind}
+        result = {
+            "kind": self.kind,
+            "defer_loading": self.defer_loading,
+        }
         if self.rag_lancedb_stem is not None:
             result["rag_lancedb_stem"] = self.rag_lancedb_stem
         else:
@@ -383,6 +404,7 @@ class BwrapSandboxSkillConfig:
     allowed_environments: bwrap_sandbox.AllowedEnvironments = None
     sandbox_config: bs_config.Config = None
     volumes: bs_models.VolumeMap = _default_dict_field()
+    defer_loading: bool = False
 
     @classmethod
     def from_yaml(
@@ -420,6 +442,7 @@ class BwrapSandboxSkillConfig:
             sandbox_config=self.sandbox_config,
             volumes=self.volumes,
             installation_config=self._installation_config,
+            defer_loading=self.defer_loading,
         )
 
     @property
@@ -427,6 +450,7 @@ class BwrapSandboxSkillConfig:
         result = {
             "kind": self.kind,
             "default_environment": self.default_environment,
+            "defer_loading": self.defer_loading,
         }
         if self.id is not None:
             result["id"] = self.id
@@ -475,6 +499,7 @@ class EntrypointCapabilityConfig:
 
     name: str
     params: dict[str, typing.Any] = _default_dict_field()
+    defer_loading: bool = True
 
     def __post_init__(self) -> None:
         # Register the capability's typed AG-UI state feature so the room can
@@ -500,10 +525,13 @@ class EntrypointCapabilityConfig:
         params = dict(config_dict)
         params.pop("kind", None)
         name = params.pop("name", None)
+        # Soliplex's own flag, not one of the plugin's parameters.
+        defer_loading = params.pop("defer_loading", True)
         try:
             return cls(
                 name=name,
                 params=params,
+                defer_loading=defer_loading,
                 _installation_config=installation_config,
                 _config_path=config_path,
             )
@@ -521,7 +549,7 @@ class EntrypointCapabilityConfig:
     @property
     def capability(self) -> ai_capabilities.AbstractCapability:
         return self._module.create_capability(
-            defer_loading=True, **self.params
+            defer_loading=self.defer_loading, **self.params
         )
 
     @property
@@ -543,7 +571,12 @@ class EntrypointCapabilityConfig:
 
     @property
     def as_yaml(self) -> dict:
-        return {"kind": self.kind, "name": self.name, **self.params}
+        return {
+            "kind": self.kind,
+            "name": self.name,
+            "defer_loading": self.defer_loading,
+            **self.params,
+        }
 
     @property
     def extra_parameters(self) -> dict[str, typing.Any]:
@@ -611,24 +644,57 @@ def extract_skill_configs(
     return skill_configs
 
 
+@dataclasses.dataclass(kw_only=True)
+class InstallationSkillRef:
+    """A room's reference to one of the installation's skills.
+
+    Spelled as a bare name, or as a mapping when the room sets a flag.
+    """
+
+    name: str
+    defer_loading: bool = True
+
+    @classmethod
+    def from_yaml(cls, entry: str | dict | InstallationSkillRef):
+        if isinstance(entry, cls):
+            return entry
+        if isinstance(entry, str):
+            return cls(name=entry)
+        return cls(**entry)
+
+    @property
+    def as_yaml(self) -> str | dict:
+        return {"name": self.name, "defer_loading": self.defer_loading}
+
+
 @dataclasses.dataclass(kw_only=True)
 class RoomSkillsConfig:
     """Select native capabilities for a room."""
 
-    installation_skill_names: list[str] = _default_list_field()
+    installation_skill_names: list[InstallationSkillRef] = (
+        _default_list_field()
+    )
     _skill_configs: SkillConfigMap = _default_dict_field()
     _installation_config: config_installation.InstallationConfig = (
         _no_repr_no_compare_none()
     )
     _config_path: pathlib.Path = None
 
+    def __post_init__(self) -> None:
+        # Callers which build the config directly, rather than via
+        # 'from_yaml', may spell the entries as bare names.
+        self.installation_skill_names = [
+            InstallationSkillRef.from_yaml(entry)
+            for entry in self.installation_skill_names
+        ]
+
     @staticmethod
     def _check_installation_skills(
         installation_config: config_installation.InstallationConfig,
         config_path: pathlib.Path,
-        config_dict: dict,
+        refs: typing.Sequence[InstallationSkillRef],
     ) -> None:
-        requested = set(config_dict.get("installation_skill_names", ()))
+        requested = {ref.name for ref in refs}
         available = set(installation_config.skill_configs)
         if missing := requested - available:
             raise MissingSkillNames(
@@ -645,11 +711,16 @@ class RoomSkillsConfig:
         config_dict: dict,
     ):
         try:
+            refs = [
+                InstallationSkillRef.from_yaml(entry)
+                for entry in config_dict.get("installation_skill_names", ())
+            ]
             cls._check_installation_skills(
                 installation_config,
                 config_path,
-                config_dict,
+                refs,
             )
+            config_dict["installation_skill_names"] = refs
             config_dict["_skill_configs"] = extract_skill_configs(
                 installation_config,
                 config_path,
@@ -671,7 +742,9 @@ class RoomSkillsConfig:
     def as_yaml(self) -> dict:
         result = {}
         if self.installation_skill_names:
-            result["installation_skill_names"] = self.installation_skill_names
+            result["installation_skill_names"] = [
+                ref.as_yaml for ref in self.installation_skill_names
+            ]
         if self._skill_configs:
             result["skill_configs"] = [
                 config.as_yaml for config in self._skill_configs.values()
@@ -682,8 +755,10 @@ class RoomSkillsConfig:
     def skill_configs(self) -> SkillConfigMap:
         installation_configs = self._installation_config.skill_configs
         return {
-            name: installation_configs[name]
-            for name in self.installation_skill_names
+            ref.name: installation_configs[ref.name].with_defer_loading(
+                ref.defer_loading
+            )
+            for ref in self.installation_skill_names
         } | self._skill_configs
 
     @property

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/installation.py

@@ -178,7 +178,7 @@ class Installation:
                 type_info = found.setdefault(provider_type, {})
                 base_url = agent_config.llm_provider_base_url
                 url_models = type_info.setdefault(base_url, set())
-                url_models.add(agent_config.model_name)
+                url_models.add(agent_config.llm_model_name)
 
         return found
 

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/models.py

@@ -174,7 +174,7 @@ ConfiguredSkills = dict[str, Skill]
 
 class DefaultAgent(pydantic.BaseModel):
     id: str
-    model_name: str
+    model_name: str | None
     retries: int
     system_prompt: str | None
     provider_type: config_agents.LLMProviderType  # enum, not dataclass
@@ -187,7 +187,7 @@ class DefaultAgent(pydantic.BaseModel):
         llm_provider_kw = agent_config.llm_provider_kw
         return cls(
             id=agent_config.id,
-            model_name=agent_config.model_name,
+            model_name=agent_config.llm_model_name,
             retries=agent_config.retries,
             system_prompt=agent_config.get_system_prompt(),
             provider_type=agent_config.provider_type,

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/quizzes.py

@@ -52,7 +52,7 @@ def get_quiz_judge_agent(quiz: config_quizzes.QuizConfig):
         model_provider = ollama_providers.OllamaProvider(**llm_provider_kw)
 
     ollama_model = openai_models.OpenAIChatModel(
-        model_name=quiz.judge_agent.model_name,
+        model_name=quiz.judge_agent.llm_model_name,
         provider=model_provider,
     )
 

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/skills/bwrap_sandbox/SKILL.md

@@ -55,11 +55,30 @@ Do NOT use the sandbox if **any** of these is true:
 - `run_python(script, environment_name=None, timeout=None)` — run a Python
   script. `script` is the full source as one string.
 
-When calling `run` and `run_python`, `environment_name` and `timeout` are both
-optional and fall back to the values this skill was configured with.
-Always pass `environment_name` explicitly, using a name that
-`list_environments` returned — the configured default is not visible to you
-and may not be the environment you want.
+## Environment names come only from `list_environments`
+
+**Never guess an environment name.** The only values `environment_name`
+accepts are the exact `name` strings that a `list_environments` call
+returned **to you, in this conversation**.
+
+- Call `list_environments` before the first `run` or `run_python` of a
+  turn. It is cheap; skipping it is the most common way this skill fails.
+- Every environment name written in this document is a placeholder —
+  `<name from list_environments>` — standing in for a name you have yet to
+  look up. No placeholder names a real environment.
+- A name that appears in a task, a filename, a library you plan to import,
+  or an earlier conversation is not an environment name. Neither is the
+  name of a package: an environment's `name` and its `dependencies` are
+  different things, and are usually spelled differently.
+- Passing a name that was not in the `list_environments` result fails the
+  call. The failure names the environments you may actually use — call
+  `list_environments` and retry with one of those, rather than guessing
+  again.
+
+`environment_name` and `timeout` are both optional and fall back to the
+values this skill was configured with. Always pass `environment_name`
+explicitly: the configured default is not visible to you and may not be
+the environment you want.
 
 ## Workflow
 
@@ -68,9 +87,9 @@ and may not be the environment you want.
 
    ```python
    {
-      "name": "pandas",
-      "description": "Minimal Python with Pandas",
-      "dependencies": ["pandas"],
+      "name": "<name from list_environments>",
+      "description": "<what this environment is for>",
+      "dependencies": ["<installed package>"],
    }
    ```
 
@@ -78,10 +97,11 @@ and may not be the environment you want.
    - If the list is empty, stop and tell the user the skill
      is not configured — do not proceed.
    - If the list contains exactly one environment, use its `name`.
-   - Otherwise, pick the `name` of the first environment whose `dependencies`
-     include a library the task needs (e.g. `pandas` for tabular data,
-     `numpy` for numeric work, `pillow` for images).  If no environments
-     match, use the `name` of the first entry in the list.
+   - Otherwise, compare the task against each entry's `dependencies` —
+     a `pandas` dependency suits tabular data, `numpy` numeric work,
+     `pillow` images — and use the `name` of the first entry that matches.
+     Use the entry's `name`, not the name of the dependency that matched.
+     If no entry matches, use the `name` of the first entry in the list.
 
 2. **List files in both volumes.**  This step is mandatory — do not skip it,
    even if the task seems to involve one volume.  Run both:
@@ -113,7 +133,7 @@ and may not be the environment you want.
 
    ```python
    run(command=["head", "-n", "5", "/sandbox/volumes/thread/orders.csv"],
-       environment_name="<selected-environment>")
+       environment_name="<name from list_environments>")
    ```
 
    (or `["wc", "-l", <path>]`, `["file", <path>]`, etc.).  For anything
@@ -125,7 +145,8 @@ and may not be the environment you want.
    argument to `run_python`:
 
    ```python
-   run_python(script="<python source>", environment_name="<selected-environment>")
+   run_python(script="<python source>",
+              environment_name="<name from list_environments>")
    ```
 
    Write the whole program as a single string, and use real newlines between
@@ -147,7 +168,10 @@ and may not be the environment you want.
    ```
 
 5. **On failure.**
-   - Change exactly one thing per retry.
+   - If the failure says the environment is not available, you guessed a
+     name. Call `list_environments` and retry with a name it returned —
+     do not try a different guess.
+   - Otherwise change exactly one thing per retry.
    - After 3 failed runs, stop. Report the error to the user (paste the
      `Exited with code: <N>` line and any traceback), instead of retrying
      further.
@@ -168,8 +192,10 @@ and may not be the environment you want.
 Task: user uploads `orders.csv` and asks "what's the total order value?".
 A full run looks like:
 
-1. `list_environments()` — shows one environment named `pandas`
-   with `pandas` in its dependencies. Use it.
+1. `list_environments()` — returns exactly one environment, whose
+   `dependencies` include `pandas`. Use that entry's `name`; in step 3 it
+   is written as `<name from list_environments>`, because what the name
+   actually is can only be read off this call's result.
 
 2. `list_volume_files("thread")` — returns
    `["/sandbox/volumes/thread/orders.csv"]`.
@@ -184,7 +210,7 @@ A full run looks like:
    df = pd.read_csv('/sandbox/volumes/thread/orders.csv')
    print(f"Total: {df['amount'].sum():.2f}")
    """,
-       environment_name="pandas",
+       environment_name="<name from list_environments>",
    )
    ```
 

{soliplex-0.77.2 → soliplex-0.78}/src/soliplex/skills/bwrap_sandbox/__init__.py

@@ -31,6 +31,10 @@ SANDBOX_WORKDIR_PATH = SKILL_PROPERTIES.metadata["sandbox_workdir_path"]
 LIST_ENVIRONMENTS_DESCRIPTION = """
 Return a list of information about available sandbox environments
 
+Call this tool before the first ``run`` or ``run_python`` of a turn: \
+their ``environment_name`` argument accepts nothing but the names \
+returned here.
+
 Each entry will contain these fields:
 - 'name' (string) pass this value to the ``run`` and ``run_python`` \
 tools to run the tool in the environment.
@@ -55,6 +59,164 @@ async def skill_list_environments(
         return candidates
 
 
+class UnknownEnvironment(pydantic_ai.ModelRetry):
+    def __init__(self, name, choices):
+        self.name = name
+        self.choices = choices
+        c_list = ", ".join(repr(name) for name in choices)
+        super().__init__(
+            f"{name!r} is not an available sandbox environment. "
+            "Environment names cannot be guessed or copied from examples: "
+            "call 'list_environments' and pass one of the names it returns. "
+            f"Available environments: {c_list}."
+        )
+
+
+class NoEnvironmentsConfigured(pydantic_ai.ToolFailed):
+    def __init__(self, name):
+        self.name = name
+        super().__init__(
+            f"{name!r} is not an available sandbox environment, "
+            "and this room has none configured. "
+            "Tell the user the sandbox skill is not configured."
+        )
+
+
+async def check_environment_name(
+    *,
+    bwrap_sandbox: bs_sandbox.BwrapSandbox,
+    environment_name: str | None,
+    allowed_environments: AllowedEnvironments = None,
+) -> None:
+    """Reject an 'environment_name' the model invented, before anything runs.
+
+    Guards 'run' / 'run_python' against a name the model guessed rather than
+    read from a 'list_environments' result. Without it, an unknown name
+    aborts the whole agent run, and a name which exists but is *not* in
+    'allowed_environments' runs anyway -- 'allowed_environments' otherwise
+    only filters what 'list_environments' reports.
+
+    The two failures differ in whether the model can do anything about them,
+    so they are reported differently. A name outside the choices is fixable
+    by calling 'list_environments' and passing one of them, which is what
+    'ModelRetry' asks for (and matches how 'pydantic_ai' itself reports an
+    unknown *tool* name). A room with no environments at all is the
+    operator's to fix: 'ToolFailed' shows the model a failed call to report
+    rather than one to retry, and spends none of the tool's retry budget.
+
+    'None' passes through unchecked: it selects the environment the skill was
+    configured with, which is the operator's choice rather than the model's.
+    """
+    if environment_name is None:
+        return
+
+    available = [
+        env.name
+        for env in await skill_list_environments(
+            bwrap_sandbox=bwrap_sandbox,
+            allowed_environments=allowed_environments,
+        )
+    ]
+
+    if environment_name in available:
+        return
+
+    if not available:
+        raise NoEnvironmentsConfigured(name=environment_name)
+
+    raise UnknownEnvironment(
+        name=environment_name,
+        choices=available,
+    )
+
+
+def _environment_label(environment_name):
+    """Name the environment a run asked for, without leaking host paths.
+
+    'bubble_sandbox' builds its messages from the resolved filesystem path
+    ("Environment not found: PosixPath('/app/sandbox/environments/...')"),
+    which is meaningless inside the sandbox and not something to put in
+    front of the model. The requested name says the same thing.
+    """
+    if environment_name is None:
+        return "the environment this room uses by default"
+    return f"the {environment_name!r} environment"
+
+
+class EnvironmentMissing(pydantic_ai.ToolFailed):
+    def __init__(self, environment_name):
+        self.environment_name = environment_name
+        super().__init__(
+            f"The sandbox cannot run: {_environment_label(environment_name)} "
+            "is not installed on this server. Report this to the user as a "
+            "sandbox configuration problem; retrying will not fix it."
+        )
+
+
+class EnvironmentNotBuilt(pydantic_ai.ToolFailed):
+    def __init__(self, environment_name):
+        self.environment_name = environment_name
+        super().__init__(
+            f"The sandbox cannot run: {_environment_label(environment_name)} "
+            "is installed but its Python virtualenv is missing. Report this "
+            "to the user as a sandbox configuration problem; retrying will "
+            "not fix it."
+        )
+
+
+class EnvironmentNameInvalid(pydantic_ai.ToolFailed):
+    def __init__(self, environment_name):
+        self.environment_name = environment_name
+        super().__init__(
+            f"The sandbox cannot run: {_environment_label(environment_name)} "
+            "is not a usable environment name. Report this to the user as a "
+            "sandbox configuration problem; retrying will not fix it."
+        )
+
+
+class SandboxUnavailable(pydantic_ai.ToolFailed):
+    def __init__(self, environment_name, reason):
+        self.environment_name = environment_name
+        self.reason = reason
+        super().__init__(
+            "The sandbox could not be started in "
+            f"{_environment_label(environment_name)}: {reason}. Report this "
+            "to the user; retrying will not fix it."
+        )
+
+
+# 'bubble_sandbox' reports a bad environment name with 'ValueError' and
+# 'FileNotFoundError' subclasses, not 'RuntimeError'; letting one escape
+# aborts the agent run (soliplex#1306) instead of handing the model an
+# error it can act on.
+EXECUTION_ERRORS = (
+    RuntimeError,
+    OSError,
+    bs_config.InvalidEnvironmentName,
+)
+
+
+def translate_execution_error(exc, *, environment_name):
+    """Return the error the model should see for a failed sandbox start.
+
+    Every case here is the operator's to fix rather than the model's --
+    'check_environment_name' has already rejected any name the model could
+    have chosen differently -- so each maps to a 'ToolFailed' subclass: the
+    model sees a failed call to report, spends none of the tool's retry
+    budget, and is told plainly that retrying will not help.
+    """
+    if isinstance(exc, bs_config.EnvironmentNotFound):
+        return EnvironmentMissing(environment_name)
+
+    if isinstance(exc, bs_config.EnvironmentNotInitialized):
+        return EnvironmentNotBuilt(environment_name)
+
+    if isinstance(exc, bs_config.InvalidEnvironmentName):
+        return EnvironmentNameInvalid(environment_name)
+
+    return SandboxUnavailable(environment_name, str(exc))
+
+
 RUN_DESCRIPTION = f"""\
 Run a shell command inside the bubblewrap sandbox.
 
@@ -69,8 +231,10 @@ pass ``command`` as a single string; it is run via "sh -c".
 - Otherwise pass ``command`` as a list of strings: the executable name \
 or path first, then one element per argument. This form needs no \
 quoting and is the safer default.
-- ``environment_name`` selects the environment to run in; omit it to \
-use the configured default. Call ``list_environments`` for the choices.
+- ``environment_name`` selects the environment to run in. Pass only a \
+``name`` that ``list_environments`` returned in this conversation -- \
+never a guessed name, a package name, or a name copied from an example. \
+Omit it to use the configured default.
 - ``timeout`` caps the run in seconds; omit it to use the configured \
 default.
 - Paths must be absolute and sandbox-visible: read inputs from \
@@ -159,8 +323,11 @@ async def skill_run(
             timeout=timeout,
             extra_volumes=extra_volumes,
         )
-    except RuntimeError as e:
-        return f"Error: {e}"
+    except EXECUTION_ERRORS as exc:
+        raise translate_execution_error(
+            exc,
+            environment_name=environment_name,
+        ) from exc
 
     output = result.output
     if result.truncated:
@@ -182,9 +349,10 @@ Do NOT pass shell commands — use the ``run`` tool for those.
 - Pass a complete, self-contained Python script as the ``script`` string.
 - The script runs via the Python interpreter built into the chosen \
 environment, with access to its pre-installed packages.
-- Use ``list_environments`` first to discover available environments \
-and their installed packages. ``environment_name`` selects one; omit \
-it to use the configured default.
+- Call ``list_environments`` first to discover available environments \
+and their installed packages. ``environment_name`` must be one of the \
+``name`` values it returned -- never a guessed name, a package name, or \
+a name copied from an example. Omit it to use the configured default.
 - ``timeout`` caps the run in seconds; omit it to use the configured \
 default.
 - Print results to stdout — the output is captured and returned.
@@ -235,8 +403,11 @@ async def skill_run_python(
             timeout=timeout,
             extra_volumes=extra_volumes,
         )
-    except RuntimeError as e:
-        return f"Error: {e}"
+    except EXECUTION_ERRORS as exc:
+        raise translate_execution_error(
+            exc,
+            environment_name=environment_name,
+        ) from exc
 
     output = result.output
     if result.truncated:
@@ -434,6 +605,12 @@ def create_sandbox_toolset(
         environment_name: str | None = None,
         timeout: float | None = None,  # seconds
     ) -> str:
+        await check_environment_name(
+            bwrap_sandbox=bwrap_sandbox,
+            environment_name=environment_name,
+            allowed_environments=allowed_environments,
+        )
+
         deps = ctx.deps
         workdir = get_workdir(
             workdirs_path,
@@ -486,6 +663,12 @@ def create_sandbox_toolset(
         environment_name: str | None = None,
         timeout: float | None = None,  # seconds
     ) -> str:
+        await check_environment_name(
+            bwrap_sandbox=bwrap_sandbox,
+            environment_name=environment_name,
+            allowed_environments=allowed_environments,
+        )
+
         deps = ctx.deps
         workdir = get_workdir(
             workdirs_path,
@@ -570,11 +753,12 @@ def create_bwrap_sandbox_capability(
     volumes: bs_models.VolumeMap | None = None,
     max_retries: int = 1,
     installation_config=None,  # noqa F821 cycles
+    defer_loading: bool = False,
 ) -> SandboxCapability:
     return SandboxCapability(
         id=id or SKILL_PROPERTIES.name,
         description=SKILL_PROPERTIES.description.strip(),
-        defer_loading=True,
+        defer_loading=defer_loading,
         default_environment=default_environment,
         allowed_environments=allowed_environments,
         sandbox_config=sandbox_config,

{soliplex-0.77.2 → soliplex-0.78/src/soliplex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.77.2
+Version: 0.78
 Summary: An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface.
 Author-email: Enfold <info@enfoldsystems.net>
 Classifier: Programming Language :: Python :: 3