databricks-tellr-app 0.4.3.dev35__tar.gz → 0.4.3.dev37__tar.gz

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.3.dev35
+Version: 0.4.3.dev37
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/databricks_tellr_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.3.dev35
+Version: 0.4.3.dev37
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "databricks-tellr-app"
-version = "0.4.3.dev35"
+version = "0.4.3.dev37"
 description = "Tellr application package for Databricks Apps"
 readme = "README.md"
 requires-python = ">=3.10"

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/api/routes/agent_definitions.py

@@ -260,6 +260,7 @@ def _probe_result_response(
         endpoint_name=identity.endpoint_name,
         candidate_hash=identity.candidate_hash,
         lock_version=identity.lock_version,
+        provider_detail=failure.provider_detail,
     )
     return JSONResponse(
         status_code=_PROBE_FAILURE_STATUS[failure.code],

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/api/schemas/agent_definitions.py

@@ -508,6 +508,9 @@ class StructuredOutputProbeFailureResponse(BaseModel):
     endpoint_name: str
     candidate_hash: str = Field(pattern=_LOWERCASE_SHA256)
     lock_version: int
+    #: Sanitised provider reason, present only on the probe route (admin workbench only).
+    #: Never included on runtime graph-turn error paths.
+    provider_detail: str | None = None
 
 
 # --- Agent Test Cases (#267) -------------------------------------------------

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/api/services/chat_service.py

@@ -286,6 +286,25 @@ def resolve_engine_mode_or_unavailable(session_id: Optional[str]) -> str:
         ) from exc
 
 
+#: The one client-facing text for a graph turn that failed for any reason other
+#: than a typed pinned-configuration failure.  Code-owned: the exception's own
+#: text can carry model output (a parser error names the provider-chosen tool,
+#: a ``ValidationError`` echoes the provider's arguments), so it never reaches
+#: the stream event, the re-raised error or a route's error text (ws2a
+#: follow-up A, fix round 1).
+GRAPH_TURN_FAILED_MESSAGE = "The request could not be completed. Please try again."
+
+
+class GraphTurnFailedError(RuntimeError):
+    """A failed graph turn, re-raised with a code-owned message.
+
+    The original exception is kept only as ``__cause__`` (for server logs).
+    """
+
+    def __init__(self) -> None:
+        super().__init__(GRAPH_TURN_FAILED_MESSAGE)
+
+
 def _pinned_graph_configuration_error_event() -> StreamEvent:
     """The one safe, typed event for an unavailable pinned graph configuration."""
     return StreamEvent(
@@ -1970,14 +1989,24 @@ class ChatService:
                 error_container["error"] = graph_error
                 event_queue.put(_pinned_graph_configuration_error_event())
             except Exception as e:
+                # The traceback (server-side only) keeps the cause; the client
+                # gets the code-owned message, never ``str(e)``.
                 logger.error(
-                    f"Graph turn failed: {e}",
-                    extra={"session_id": session_id},
+                    "Graph turn failed",
+                    extra={"session_id": session_id, "error_class": type(e).__name__},
                     exc_info=True,
                 )
-                error_container["error"] = e
+                if isinstance(e, SessionNotFoundError):
+                    # The routes map this type to their own code-owned text.
+                    error_container["error"] = e
+                else:
+                    failure = GraphTurnFailedError()
+                    failure.__cause__ = e
+                    error_container["error"] = failure
                 event_queue.put(
-                    StreamEvent(type=StreamEventType.ERROR, error=str(e))
+                    StreamEvent(
+                        type=StreamEventType.ERROR, error=GRAPH_TURN_FAILED_MESSAGE
+                    )
                 )
             finally:
                 # Signal completion by putting None

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/api/services/session_naming.py

@@ -100,6 +100,9 @@ def build_session_title_model():
     sends the same user message to the Gateway as the service principal, so
     this adds no new data exposure. Per-user identity on Gateway calls is
     workstream 2b (it needs the ``ai-gateway`` user scope and user re-consent).
+
+    No sampling parameter is sent: newer Claude models on the Gateway reject
+    ``temperature`` with a 400 (ws2a follow-up A).
     """
     from databricks_langchain import ChatDatabricks
 
@@ -110,7 +113,6 @@ def build_session_title_model():
         model=SESSION_TITLE_MODEL,
         use_ai_gateway=True,
         max_tokens=50,
-        temperature=0.3,
         workspace_client=get_system_client(),
     )
 

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/services/agent_runtime.py

@@ -121,6 +121,14 @@ class ProtectedPromptIdentity:
 
 @dataclass(frozen=True)
 class AgentModelConfiguration:
+    """One role's saved model configuration.
+
+    ``temperature`` and ``top_p`` are stored, hashed and published as saved, but
+    they are NOT sent to the model (ws2a follow-up A): newer Claude models on
+    Unity AI Gateway reject sampling parameters with a 400.  Only
+    ``endpoint_name`` and ``max_tokens`` reach the provider.
+    """
+
     endpoint_name: str
     temperature: float
     max_tokens: int
@@ -223,6 +231,17 @@ def bind_structured_output_model(
     test-run adapter built by ``get_agent_test_runtime``.  The production
     runtime adapter passes none.
 
+    What is sent (ws2a follow-up A): the model is constructed with the endpoint
+    and ``max_tokens`` only.  The saved ``temperature`` / ``top_p`` are never
+    sent — newer Claude models reject them ("does not support the temperature
+    parameter").  ``schema`` is bound as the one tool with
+    ``tool_choice="auto"``: this is ``ChatDatabricks.with_structured_output``'s
+    function-calling branch, whose forced tool choice (``type "tool"``) newer
+    models also reject.  Under ``auto`` a model may reply without calling the
+    tool; the parser then yields ``None`` and :func:`_require_structured_output`
+    raises ``OutputParserException``, the same parse-error class a malformed
+    tool call raises (see ``_is_provider_parse_error``).
+
     Only while a #267 test run's model call is in flight (its ``RunObservation``
     is the observed run) is the bound model given a callback that records the
     provider's reported token usage onto that observation.  The binding itself
@@ -230,21 +249,41 @@ def bind_structured_output_model(
     production's; production ``run`` observes nothing and gets exactly
     the plain structured-output binding of ``schema``.
     """
+    # Imported lazily, like the chat model itself: the module stays import-light.
+    from langchain_core.output_parsers.openai_tools import PydanticToolsParser
+    from langchain_core.runnables import RunnableLambda
+
     model = model_factory(
         model=configuration.endpoint_name,
-        temperature=configuration.temperature,
         max_tokens=configuration.max_tokens,
-        top_p=configuration.top_p,
         workspace_client=workspace_client,
         **(transport_options or {}),
     )
-    structured_model = model.with_structured_output(schema)
+    structured_model = (
+        model.bind_tools([schema], tool_choice="auto")
+        | PydanticToolsParser(tools=[schema], first_tool_only=True)
+        | RunnableLambda(_require_structured_output)
+    )
     observation = _OBSERVED_TEST_RUN.get()
     if observation is None:
         return structured_model
     return structured_model.with_config(callbacks=[_token_usage_callback(observation)])
 
 
+def _require_structured_output(parsed: Any) -> Any:
+    """Refuse a reply that called no tool (``tool_choice="auto"`` permits one).
+
+    The message is code-owned: provider text never reaches it.
+    """
+    if parsed is None:
+        from langchain_core.exceptions import OutputParserException
+
+        raise OutputParserException(
+            "the model replied without calling the structured-output tool"
+        )
+    return parsed
+
+
 def _token_count(value: Any) -> int | None:
     """A provider-reported count, or ``None``: only a non-negative ``int`` is a count."""
     if isinstance(value, int) and not isinstance(value, bool) and value >= 0:
@@ -301,7 +340,7 @@ def _token_usage_callback(observation: RunObservation) -> Any:
 
 
 class DatabricksModelAdapter:
-    """Invoke one structured Databricks model without binding any tools."""
+    """Invoke one structured Databricks model; the output schema is its only tool."""
 
     def __init__(
         self,

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/services/graph/nodes.py

@@ -716,9 +716,10 @@ def _design_system_library() -> List[dict]:
     """Every live design system with its templates — §M1, delivered as payload.
 
     §M1 asks for "the architect's tool manifest" to carry the design-system
-    library.  **There is no manifest.** ``TOOL_GRANTS`` is ``[]``, ``bind_tools``
-    appears nowhere under ``src/``, and AgentRuntime invokes the architect with
-    structured output and no tools bound at all, so a library wired into
+    library.  **There is no manifest.** ``TOOL_GRANTS`` is ``[]``, the one
+    ``bind_tools`` under ``src/`` binds only the output schema (the structured-
+    output binding in ``agent_runtime``), and AgentRuntime invokes the architect
+    with structured output and no other tool bound, so a library wired into
     ``tool_grants`` would be read by nothing.  The operator ratified delivering
     §M1 through the architect's **payload** instead, beside
     ``available_design_contract`` and ``template_sections`` — the only channel

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/services/html_to_google_slides.py

@@ -834,7 +834,6 @@ class HtmlToGoogleSlidesConverter:
                     {"role": "system", "content": system_prompt},
                     {"role": "user", "content": user_prompt},
                 ],
-                temperature=0.2,
                 max_tokens=16384,
                 timeout=300,
                 extra_body={"thinking": {"type": "enabled", "budget_tokens": thinking_budget}},

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/services/html_to_pptx.py

@@ -527,7 +527,6 @@ class HtmlToPptxConverterV3:
                     {"role": "system", "content": system_prompt},
                     {"role": "user", "content": user_prompt}
                 ],
-                temperature=0.2,
                 max_tokens=16384,
                 timeout=300,
                 extra_body={

{databricks_tellr_app-0.4.3.dev35 → databricks_tellr_app-0.4.3.dev37}/src/services/model_endpoint_probe.py

@@ -16,13 +16,15 @@ Ownership boundaries:
 
 from __future__ import annotations
 
+import json
 import logging
+import re
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from typing import Any, Literal, Protocol
 
 import openai
-from databricks.sdk.errors import PermissionDenied
+from databricks.sdk.errors import DatabricksError, PermissionDenied
 from pydantic import BaseModel, ConfigDict
 from sqlalchemy.orm import Session
 
@@ -55,11 +57,14 @@ class StructuredOutputProbeFailure(RuntimeError):  # noqa: N818 - stable public
         code: StructuredOutputProbeCode,
         message: str,
         retryable: bool,
+        *,
+        provider_detail: str | None = None,
     ) -> None:
         super().__init__(message)
         self.code = code
         self.message = message
         self.retryable = retryable
+        self.provider_detail = provider_detail
 
 
 _UNSUPPORTED = (
@@ -187,6 +192,110 @@ class DatabricksStructuredOutputProbe:
             raise _failure(_FAILED, None)
 
 
+#: Dashed-UUID pattern (8-4-4-4-12) preserved for support diagnostics (e.g. ReqId).
+_DASHED_UUID_RE = re.compile(
+    r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
+)
+_UUID_PLACEHOLDER = "\x00UUID\x00"
+#: Strip URLs, bearer/dapi/JWT-like tokens, and long undashed hex/base64 runs.
+#: Dashed UUIDs are excluded via pre/post substitution in _sanitise_provider_detail.
+_URL_RE = re.compile(r"https?://\S+")
+_TOKEN_RE = re.compile(r"\b(?:Bearer|dapi)[^\s,;\"']+", re.IGNORECASE)
+_HEX_BASE64_RE = re.compile(r"[A-Za-z0-9+/=_\-]{32,}")
+_WHITESPACE_RE = re.compile(r"\s+")
+_PROVIDER_DETAIL_CAP = 300
+
+
+def _sanitise_provider_detail(raw: str) -> str:
+    """Sanitise a provider error string for safe display.
+
+    Attempts to extract a message string from a JSON body, supporting:
+    - ``{"message": ...}`` (Gateway body; the value may itself be nested JSON)
+    - ``{"error": {"message": ...}}`` (openai-style error body)
+
+    After extraction, strips URLs, bearer/dapi tokens, and long undashed hex/base64
+    runs (≥32 chars).  Dashed UUIDs (8-4-4-4-12 hex, e.g. request IDs) are preserved.
+    Collapses whitespace and caps at 300 characters.
+    """
+    # Try to parse as JSON and extract the message field.
+    text = raw
+    try:
+        obj = json.loads(raw)
+        if isinstance(obj, dict):
+            # Prefer top-level "message" (Gateway body shape).
+            msg: str | None = None
+            if isinstance(obj.get("message"), str):
+                msg = obj["message"]
+            # Fall back to openai-style {"error": {"message": ...}}.
+            elif isinstance(obj.get("error"), dict):
+                err = obj["error"]
+                if isinstance(err.get("message"), str):
+                    msg = err["message"]
+            if msg is not None:
+                # Try one level of nested JSON (Gateway body shape).
+                try:
+                    inner = json.loads(msg)
+                    if isinstance(inner, dict) and isinstance(inner.get("message"), str):
+                        text = inner["message"]
+                    else:
+                        text = msg
+                except (json.JSONDecodeError, ValueError):
+                    text = msg
+    except (json.JSONDecodeError, ValueError):
+        pass
+
+    # Strip URLs.
+    text = _URL_RE.sub("", text)
+    # Strip bearer/dapi tokens.
+    text = _TOKEN_RE.sub("", text)
+    # Preserve dashed UUIDs (8-4-4-4-12) before stripping long hex/base64 runs.
+    # They carry request IDs useful for support diagnostics.
+    uuids = _DASHED_UUID_RE.findall(text)
+    text = _DASHED_UUID_RE.sub(_UUID_PLACEHOLDER, text)
+    # Strip long undashed hex/base64 runs (>= 32 chars).
+    text = _HEX_BASE64_RE.sub("", text)
+    # Restore dashed UUIDs.
+    for uuid in uuids:
+        text = text.replace(_UUID_PLACEHOLDER, uuid, 1)
+    # Collapse whitespace.
+    text = _WHITESPACE_RE.sub(" ", text).strip()
+    # Cap at 300 characters.
+    if len(text) > _PROVIDER_DETAIL_CAP:
+        text = text[:_PROVIDER_DETAIL_CAP] + "…"
+    return text
+
+
+def _extract_provider_detail(error: BaseException) -> str | None:
+    """Extract a sanitised provider detail string from an error, if available.
+
+    Tries to find a JSON body (openai errors carry ``response.text`` or
+    ``body``), falling back to ``str(error)``.  Returns ``None`` when the
+    error carries no useful provider text (e.g. connection errors without a
+    body).
+    """
+    # openai errors carry the raw response body.
+    body: str | None = None
+    if isinstance(error, openai.APIStatusError):
+        # openai >= 1.x: .response.text is the raw body; .body is the parsed dict.
+        try:
+            body = error.response.text
+        except Exception:  # noqa: BLE001
+            pass
+        if not body:
+            try:
+                body = json.dumps(error.body) if error.body else None
+            except Exception:  # noqa: BLE001
+                pass
+    elif isinstance(error, DatabricksError):
+        body = str(error) or None
+
+    if not body:
+        return None
+
+    detail = _sanitise_provider_detail(body)
+    return detail if detail else None
+
+
 def _failure(
     outcome: tuple[StructuredOutputProbeCode, str, bool],
     error: BaseException | None,
@@ -198,7 +307,10 @@ def _failure(
         code,
         type(error).__name__ if error is not None else "unexpected_output",
     )
-    return StructuredOutputProbeFailure(code, message, retryable)
+    detail: str | None = None
+    if error is not None and isinstance(error, (openai.APIStatusError, DatabricksError)):
+        detail = _extract_provider_detail(error)
+    return StructuredOutputProbeFailure(code, message, retryable, provider_detail=detail)
 
 
 class FakeStructuredOutputProbe: