xpander-sdk 2.0.414__tar.gz → 2.0.415__tar.gz

{xpander_sdk-2.0.414/src/xpander_sdk.egg-info → xpander_sdk-2.0.415}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xpander-sdk
-Version: 2.0.414
+Version: 2.0.415
 Summary: xpander.ai Backend-as-a-service for AI Agents - SDK
 Home-page: https://www.xpander.ai
 Author: xpanderAI

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="xpander-sdk",
-    version="2.0.414",
+    version="2.0.415",
     author="xpanderAI",
     author_email="dev@xpander.ai",
     description="xpander.ai Backend-as-a-service for AI Agents - SDK",

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415}/src/xpander_sdk/__init__.py

@@ -15,7 +15,7 @@ Main Components:
 For more information, visit: https://xpander.ai
 """
 
-__version__ = "2.0.414"
+__version__ = "2.0.415"
 
 # Backend-related imports
 from .modules.backend.backend_module import Backend

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415}/src/xpander_sdk/core/context_optimizer/finalize_mode.py

@@ -18,10 +18,13 @@ already-large ``context_optimizer.py`` and out of the agno hook in
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from loguru import logger
 
+from xpander_sdk.core.context_optimizer.action_ledger import get_attached_ledger
+from xpander_sdk.utils.json_parsing import parse_structured_string
+
 from xpander_sdk.models.action_ledger import (
     EvidenceReport,
     FinalizeOnlyState,
@@ -171,7 +174,15 @@ def build_finalize_tool(task: Any) -> Any:
     """
     from agno.tools.function import Function
 
-    async def _entrypoint(payload: Optional[Dict[str, Any]] = None) -> str:
+    async def _entrypoint(
+        payload: Optional[Union[Dict[str, Any], str]] = None,
+    ) -> str:
+        # LLMs sometimes emit the payload as a JSON string; validate_call
+        # accepts it via the Union, we parse here. An unparseable string is
+        # kept as the final answer — finalize must terminate, never bounce.
+        if isinstance(payload, str):
+            parsed = parse_structured_string(payload)
+            payload = parsed if isinstance(parsed, dict) else {"final_answer": payload}
         data = payload or {}
         final_answer = data.get("final_answer", "") or ""
         completed_items = data.get("completed_items") or []
@@ -258,17 +269,43 @@ async def _run_finalize(
     # Mark plan items as completed via the deep_planning model (no
     # round-trip through xpcomplete_agent_plan_items needed; the SDK
     # serializes deep_planning back on the next status update).
+    evidence_note = ""
     try:
         if (
             completed_items
             and getattr(task, "deep_planning", None)
             and task.deep_planning.tasks
         ):
-            wanted = set(completed_items)
-            for item in task.deep_planning.tasks:
-                if item.id in wanted and not item.completed:
-                    item.completed = True
-            logger.info(f"[finalize-mode] marked {len(wanted)} plan item(s) complete")
+            # Soft evidence gate: when the ledger recorded tool calls and every
+            # single one failed, the LLM's completed_items claim is fabricated —
+            # keep the items open and say so instead of rendering a green plan.
+            # An absent/empty ledger can't distinguish "no tools needed" from
+            # "ledger disabled", so it never blocks.
+            ledger = get_attached_ledger(task)
+            all_calls_failed = bool(
+                ledger
+                and ledger.entries
+                and all(entry.status != "ok" for entry in ledger.entries)
+            )
+            if all_calls_failed:
+                evidence_note = (
+                    "\n\n⚠️ Plan items were NOT marked completed: every recorded "
+                    "tool call in this run failed, so there is no evidence the "
+                    "work happened."
+                )
+                logger.warning(
+                    f"[finalize-mode] refused to mark {len(completed_items)} plan "
+                    f"item(s) complete — ledger has {len(ledger.entries)} entries, "
+                    "all failed"
+                )
+            else:
+                wanted = set(completed_items)
+                for item in task.deep_planning.tasks:
+                    if item.id in wanted and not item.completed:
+                        item.completed = True
+                logger.info(
+                    f"[finalize-mode] marked {len(wanted)} plan item(s) complete"
+                )
     except Exception as exc:
         logger.warning(f"[finalize-mode] plan-item update failed: {exc}")
 
@@ -279,4 +316,4 @@ async def _run_finalize(
     except Exception as exc:
         logger.warning(f"[finalize-mode] failed to set task.result: {exc}")
 
-    return final_answer or "Task finalized."
+    return (final_answer or "Task finalized.") + evidence_note

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415}/src/xpander_sdk/modules/backend/frameworks/agno.py

@@ -5,7 +5,7 @@ import shlex
 import uuid
 from collections import deque
 from os import getenv, environ
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from loguru import logger
 from xpander_sdk import Configuration
@@ -76,6 +76,7 @@ from xpander_sdk.modules.backend.utils.mcp_connect import (
     probe_recently_ok,
 )
 from xpander_sdk.modules.backend.utils.mcp_oauth import authenticate_mcp_server
+from xpander_sdk.utils.json_parsing import parse_structured_string
 from xpander_sdk.modules.backend.utils.tool_call_events import (
     coerce_json_like,
     DYNAMIC_META_TOOLS,
@@ -224,6 +225,9 @@ results/success table (rows like "applied", "updated", "created", "22/22 ✓") f
 execute — if you did not call the tool, say what you WOULD do, not that you did it.
 Never invent, quote, or attribute a prior user message or request that is not in the conversation
 above; if you are unsure whether something was asked, check or ask rather than assert it happened.
+A tool result carrying an HTTP 4xx/5xx or error(...) is a FAILURE, not an empty result. Never report
+it as "no results found" / "nothing matched" — say the lookup failed and why (quote the status), then
+fix the call (e.g. correct the identifier) or surface the failure.
 </grounding>
 """
 
@@ -544,7 +548,12 @@ def _build_compact_tool():
     """
     from agno.tools.function import Function
 
-    def _entrypoint(payload: Optional[Dict[str, Any]] = None) -> str:
+    def _entrypoint(payload: Optional[Union[Dict[str, Any], str]] = None) -> str:
+        # Stringified payloads are accepted (Union) and parsed here so a
+        # malformed emission never fails the compaction request itself.
+        if isinstance(payload, str):
+            parsed = parse_structured_string(payload)
+            payload = parsed if isinstance(parsed, dict) else {}
         focus = (payload or {}).get("focus", "") or ""
         return f"Compaction scheduled with focus: {focus}"
 
@@ -596,6 +605,30 @@ def _build_compact_tool():
     )
 
 
+def reenvelope_sibling_args(arguments: Dict[str, Any]) -> bool:
+    """Fold sibling keys of ``payload`` into the payload wrapper, in place.
+
+    Repository tools take a single ``payload`` model arg, but LLMs sometimes
+    emit args flat (``command='ls', toolcallplantaskid=''``) or float
+    ``headers``/``toolcall*`` out as siblings of ``payload``. validate_call
+    then fails with unexpected_keyword_argument / missing_argument before the
+    payload model's own before-validator can nest/backfill anything. Mutates
+    ``arguments`` in place (agno reads ``self.arguments`` directly) and returns
+    True when a fold happened. Skipped when ``payload`` is a non-dict value the
+    string-coercion step couldn't parse — nothing sane to merge into.
+    """
+    if not any(k != "payload" for k in arguments):
+        return False
+    payload_val = arguments.get("payload")
+    if payload_val is not None and not isinstance(payload_val, dict):
+        return False
+    envelope = dict(payload_val) if isinstance(payload_val, dict) else {}
+    for key in [k for k in list(arguments) if k != "payload"]:
+        envelope.setdefault(key, arguments.pop(key))
+    arguments["payload"] = envelope
+    return True
+
+
 def _classify_tool_error(error: Exception) -> str:
     """Classify a tool error as transient, auth, or client.
 
@@ -1403,6 +1436,15 @@ async def build_agent_args(
         except Exception:
             pass
 
+        # Repository tools take a single `payload` model arg; sibling kwargs
+        # would fail validate_call before the payload model's coercion runs.
+        if matched_tool is not None and isinstance(arguments, dict):
+            if reenvelope_sibling_args(arguments):
+                logger.debug(
+                    f"[tool-hook] re-enveloped sibling args into payload for "
+                    f"{function_name}"
+                )
+
         # workspace_path payload resolution: when the LLM offloaded a large
         # tool payload to a workspace file, fetch it now and replace
         # `arguments` with the resolved dict. Runs *before* activity logging

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415}/src/xpander_sdk/modules/tools_repository/utils/schemas.py

@@ -8,6 +8,7 @@ from xpander_sdk.modules.tools_repository.utils.generic import (
     json_type_to_python,
     pascal_case,
 )
+from xpander_sdk.utils.json_parsing import parse_structured_string
 
 from pydantic import BaseModel, create_model, ConfigDict
 from typing import Optional, Type, Dict, Any
@@ -29,14 +30,9 @@ class _CoercingPayloadBase(BaseModel):
     @classmethod
     def _coerce_string_payload(cls, data):
         if isinstance(data, str):
-            s = data.strip()
-            if s.startswith("{") and s.endswith("}"):
-                try:
-                    parsed = json.loads(s)
-                    if isinstance(parsed, dict):
-                        data = parsed
-                except json.JSONDecodeError:
-                    pass
+            parsed = parse_structured_string(data)
+            if isinstance(parsed, dict):
+                data = parsed
         if isinstance(data, dict):
             data = cls._nest_flat_body_params(data)
             data = cls._hoist_misplaced_reasoning_headers(data)
@@ -54,13 +50,19 @@ class _CoercingPayloadBase(BaseModel):
         call carries the arguments the model intended, merging with any partial
         body_params already present without overwriting its keys. No-op unless the
         model has a ``body_params`` field; skipped when query/path params are
-        populated to avoid misrouting a genuinely different envelope."""
+        populated to avoid misrouting a genuinely different envelope — unless
+        ``body_params`` is required and absent, where bailing out guarantees a
+        "Field required" failure and nesting is the only viable read."""
         if "body_params" not in cls.model_fields:
             return data
-        for envelope in ("query_params", "path_params"):
-            val = data.get(envelope)
-            if isinstance(val, dict) and val:
-                return data
+        body_required_and_missing = cls.model_fields[
+            "body_params"
+        ].is_required() and not isinstance(data.get("body_params"), dict)
+        if not body_required_and_missing:
+            for envelope in ("query_params", "path_params"):
+                val = data.get(envelope)
+                if isinstance(val, dict) and val:
+                    return data
         reserved = set(cls.model_fields) | {"headers", "workspace_path"}
         stray = {
             k: v

xpander_sdk-2.0.415/src/xpander_sdk/utils/json_parsing.py

@@ -0,0 +1,35 @@
+import ast
+import json
+from typing import Any, Optional
+
+
+def parse_structured_string(value: str) -> Optional[Any]:
+    """Parse a string that plausibly encodes a dict/list, returning None on failure.
+
+    Three tiers, mirroring the leniency LLM tool-call payloads need in practice:
+    strict JSON first, then ``strict=False`` (payloads with literal newlines/tabs
+    inside string values, e.g. a file-write ``content`` field), then a Python
+    literal (single quotes). Plain text never parses and returns None.
+    """
+    stripped = value.strip()
+    if not (stripped.startswith(("{", "[")) and stripped.endswith(("}", "]"))):
+        return None
+    try:
+        parsed = json.loads(stripped)
+        if isinstance(parsed, (dict, list)):
+            return parsed
+    except Exception:
+        pass
+    try:
+        parsed = json.loads(stripped, strict=False)
+        if isinstance(parsed, (dict, list)):
+            return parsed
+    except Exception:
+        pass
+    try:
+        parsed = ast.literal_eval(stripped)
+        if isinstance(parsed, (dict, list, tuple)):
+            return list(parsed) if isinstance(parsed, tuple) else parsed
+    except Exception:
+        pass
+    return None

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415/src/xpander_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xpander-sdk
-Version: 2.0.414
+Version: 2.0.415
 Summary: xpander.ai Backend-as-a-service for AI Agents - SDK
 Home-page: https://www.xpander.ai
 Author: xpanderAI

{xpander_sdk-2.0.414 → xpander_sdk-2.0.415}/src/xpander_sdk.egg-info/SOURCES.txt

@@ -132,6 +132,7 @@ src/xpander_sdk/utils/cache.py
 src/xpander_sdk/utils/env.py
 src/xpander_sdk/utils/event_loop.py
 src/xpander_sdk/utils/generic.py
+src/xpander_sdk/utils/json_parsing.py
 src/xpander_sdk/utils/tools.py
 src/xpander_sdk/utils/agents/__init__.py
 src/xpander_sdk/utils/db/__init__.py