inputlayer-client-dev 0.1.0.dev912__tar.gz → 0.1.0.dev913__tar.gz

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev913}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inputlayer-client-dev
-Version: 0.1.0.dev912
+Version: 0.1.0.dev913
 Summary: Python Object-Logic Mapper for InputLayer knowledge graph engine
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev913}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "inputlayer-client-dev"
-version = "0.1.0.dev912"
+version = "0.1.0.dev913"
 description = "Python Object-Logic Mapper for InputLayer knowledge graph engine"
 readme = "README.md"
 license = "Apache-2.0"
@@ -62,3 +62,4 @@ warn_return_any = true
 warn_unused_configs = true
 packages = ["inputlayer"]
 mypy_path = "src"
+exclude = ["examples/"]

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev913}/src/inputlayer/integrations/langchain/retriever.py

@@ -21,6 +21,21 @@ from inputlayer.integrations.langchain.params import bind_params
 
 logger = logging.getLogger(__name__)
 
+
+def _extract_error_message(result: Any) -> str:
+    """Extract the error text from an ``columns == ["error"]`` result.
+
+    Guards against missing rows and empty rows so the retriever never
+    crashes with IndexError when the engine sends a malformed error
+    envelope.
+    """
+    rows = getattr(result, "rows", None) or []
+    if not rows or not rows[0]:
+        return "unknown error"
+    msg = rows[0][0]
+    return str(msg) if msg is not None else "unknown error"
+
+
 class InputLayerRetriever(BaseRetriever):
     """Retrieve documents from an InputLayer KnowledgeGraph.
 
@@ -59,6 +74,11 @@ class InputLayerRetriever(BaseRetriever):
             )
 
     Both sync and async paths are supported natively.
+
+    When the engine rejects a query (parse error, unknown relation,
+    etc.) the retriever raises ``RuntimeError`` with the engine message
+    rather than returning empty results, so a misconfigured chain fails
+    loudly instead of silently producing zero documents.
     """
 
     kg: Any  # KnowledgeGraph - typed as Any for Pydantic compatibility
@@ -145,8 +165,9 @@ class InputLayerRetriever(BaseRetriever):
         logger.debug("IQL retriever query: %s", compiled)
         result = await self.kg.execute(compiled)
         if result.columns == ["error"]:
-            msg = result.rows[0][0] if result.rows else "unknown error"
-            raise RuntimeError(f"InputLayer rejected query: {msg}")
+            raise RuntimeError(
+                f"InputLayer rejected query: {_extract_error_message(result)}"
+            )
         return self._to_documents(result.columns, result.rows, hidden_columns=set())
 
     def _resolve_params(self, user_query: str) -> dict[str, Any]:
@@ -244,7 +265,9 @@ class InputLayerRetriever(BaseRetriever):
 
         resolved_content: list[str] = []
         content_cols = (
-            self.page_content_columns if self.page_content_columns is not None else ["content"]
+            self.page_content_columns
+            if self.page_content_columns is not None
+            else ["content"]
         )
         explicit_content = self.page_content_columns is not None
         for c in content_cols:

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev913}/src/inputlayer/integrations/langchain/tool.py

@@ -82,6 +82,10 @@ class InputLayerIQLTool(BaseTool):
        placeholder; the agent's input is safely bound (escaped, quoted)
        rather than spliced as raw text.
 
+    Engine errors are returned to the agent as ``"Error: <message>"`` so
+    the tool-calling LLM can observe the failure and adjust its next
+    action instead of the coroutine raising an exception mid-chain.
+
     Prefer ``tools_from_relations`` for normal agent use.
     """
 
@@ -137,6 +141,8 @@ class InputLayerIQLTool(BaseTool):
 
         logger.debug("IQL tool query: %s", compiled)
         result = await self.kg.execute(compiled)
+        if result.columns == ["error"]:
+            return f"Error: {_extract_error_message(result)}"
         return _format_result(result, self.max_rows)
 
 
@@ -171,7 +177,9 @@ def tools_from_relations(
         agent = create_tool_calling_agent(llm, tools, prompt)
 
     Returned tools emit JSON arrays of row dicts so tool-calling LLMs
-    can parse them directly.
+    can parse them directly. Engine errors are returned as a JSON
+    ``{"error": "<message>"}`` object rather than raising, so the agent
+    can recover from a bad filter without aborting the chain.
     """
     return [
         _relation_to_tool(kg, r, max_rows=max_rows, name_prefix=name_prefix)
@@ -343,9 +351,7 @@ def _make_relation_runner(
             logger.debug("Structured tool query: %s", q)
             result = await kg.execute(q)
             if result.columns == ["error"]:
-                return json.dumps(
-                    {"error": result.rows[0][0] if result.rows else "unknown error"}
-                )
+                return json.dumps({"error": _extract_error_message(result)})
             if not merged_columns:
                 merged_columns = result.columns
             for row in result.rows:
@@ -359,8 +365,12 @@ def _make_relation_runner(
             if len(merged_rows) >= max_rows + 1:
                 break
 
-        # Wrap merged rows in a synthetic ResultSet-like object.
-        return _format_result(_FakeResult(merged_columns, merged_rows), max_rows)
+        was_truncated = len(merged_rows) > max_rows
+        capped = merged_rows[:max_rows]
+        fake = _FakeResult(merged_columns, capped)
+        if was_truncated:
+            fake.row_count = max_rows + 1
+        return _format_result(fake, max_rows)
 
     run.__name__ = f"search_{rel_name}"
     run.parse_clauses = parse_clauses  # type: ignore[attr-defined]
@@ -393,6 +403,24 @@ def _hashable(v: Any) -> Any:
 # ── Result formatting ────────────────────────────────────────────────
 
 
+def _extract_error_message(result: Any) -> str:
+    """Extract a single error message from an ``error`` result set.
+
+    The engine signals an error with ``columns == ["error"]`` and a single
+    row whose first cell is the message. Guard against both the no-row and
+    empty-row shapes so a malformed response never masquerades as a
+    successful result or crashes the caller.
+    """
+    rows = getattr(result, "rows", None) or []
+    if not rows:
+        return "unknown error"
+    first = rows[0]
+    if not first:
+        return "unknown error"
+    msg = first[0]
+    return str(msg) if msg is not None else "unknown error"
+
+
 def _format_result(result: Any, max_rows: int) -> str:
     """Format a ResultSet as a JSON array of row dicts.
 
@@ -403,18 +431,10 @@ def _format_result(result: Any, max_rows: int) -> str:
         return "[]"
 
     rows = result.rows[:max_rows]
-    columns = result.columns
-    payload = []
-    for row in rows:
-        if len(row) != len(columns):
-            logger.warning(
-                "Row length (%d) does not match column count (%d); "
-                "truncating to shorter. Columns: %r",
-                len(row), len(columns), columns,
-            )
-        payload.append(
-            {col: _jsonify(val) for col, val in zip(columns, row, strict=False)}
-        )
+    payload = [
+        {col: _jsonify(val) for col, val in zip(result.columns, row, strict=True)}
+        for row in rows
+    ]
 
     total = getattr(result, "row_count", len(result.rows)) or len(result.rows)
     if total > max_rows:

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev913}/src/inputlayer/integrations/langchain/vector_store.py

@@ -72,6 +72,13 @@ class InputLayerVectorStore(VectorStore):
         on the provider itself, e.g.
         ``OpenAIEmbeddings(timeout=30, max_retries=2)``.
 
+    .. note::
+
+        ``add_texts`` validates that ``texts``, ``metadatas``, and ``ids``
+        all have the same length and raises ``ValueError`` up front.
+        Previously a mismatch would surface as an opaque ``zip`` error
+        deep inside the embedding call.
+
     Usage::
 
         class Chunk(Relation):
@@ -190,6 +197,17 @@ class InputLayerVectorStore(VectorStore):
         if not texts_list:
             return []
 
+        if metadatas is not None and len(metadatas) != len(texts_list):
+            raise ValueError(
+                f"Length mismatch: {len(texts_list)} texts but "
+                f"{len(metadatas)} metadata dicts"
+            )
+        if ids is not None and len(ids) != len(texts_list):
+            raise ValueError(
+                f"Length mismatch: {len(texts_list)} texts but "
+                f"{len(ids)} ids"
+            )
+
         vectors = await self._embeddings.aembed_documents(texts_list)
         ids_out = ids or [str(uuid.uuid4()) for _ in texts_list]
         metas = metadatas or [{} for _ in texts_list]
@@ -448,13 +466,14 @@ class InputLayerVectorStore(VectorStore):
             ),
         )
 
-        # Find the vector column index in the result.
-        vec_col_idx = None
-        for i, c in enumerate(result.columns):
-            if c.lower() == self._vector_field.lower():
-                vec_col_idx = i
-                break
-
+        vec_col_idx = next(
+            (
+                i
+                for i, c in enumerate(result.columns)
+                if c.lower() == self._vector_field.lower()
+            ),
+            None,
+        )
         if vec_col_idx is None:
             raise ValueError(
                 f"Could not find vector column {self._vector_field!r} in "
@@ -467,7 +486,7 @@ class InputLayerVectorStore(VectorStore):
         out: list[tuple[Document, float, list[float]]] = []
         docs_and_scores = self._rows_to_documents(result.columns, result.rows)
         for (doc, score), row in zip(docs_and_scores, result.rows, strict=True):
-            raw = row[vec_col_idx] if vec_col_idx is not None else None
+            raw = row[vec_col_idx]
             vec = list(raw) if raw is not None else []
             out.append((doc, score, vec))
         return out
@@ -584,7 +603,8 @@ class InputLayerVectorStore(VectorStore):
                 if k.lower() == self._vector_field.lower():
                     continue
                 metadata[canonical(k)] = v
-            score = float(row_dict[score_col]) if score_col else 0.0
+            raw_score = row_dict.get(score_col) if score_col else None
+            score = float(raw_score) if raw_score is not None else 0.0
             out.append((Document(page_content=content, metadata=metadata), score))
         return out
 

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev913}/tests/test_langchain.py

@@ -1741,3 +1741,154 @@ class TestDebugResultDeprecation:
         dr = DebugResult(iql="?test(X)", plan="plan text")
         with pytest.raises(AttributeError, match="no_such_field"):
             _ = dr.no_such_field
+
+
+# ═══════════════════════════════════════════════════════════════════════
+#  Edge case regression tests
+# ═══════════════════════════════════════════════════════════════════════
+
+
+class TestErrorResponseHandling:
+    """Error responses from the server should be detected, not treated as data."""
+
+    async def test_retriever_raises_on_error_response(self) -> None:
+        kg = _mock_kg(columns=["error"], rows=[["Parse error at line 1"]])
+        r = InputLayerRetriever(kg=kg, query="?bad(X)")
+        with pytest.raises(RuntimeError, match="InputLayer rejected query"):
+            await r.ainvoke("test")
+
+    async def test_retriever_raises_on_empty_error_row(self) -> None:
+        """Error response with empty row should not crash."""
+        kg = _mock_kg(columns=["error"], rows=[[]])
+        r = InputLayerRetriever(kg=kg, query="?bad(X)")
+        with pytest.raises(RuntimeError, match="unknown error"):
+            await r.ainvoke("test")
+
+    async def test_retriever_raises_on_no_rows(self) -> None:
+        """Error response with no rows at all."""
+        kg = _mock_kg(columns=["error"], rows=[])
+        r = InputLayerRetriever(kg=kg, query="?bad(X)")
+        with pytest.raises(RuntimeError, match="unknown error"):
+            await r.ainvoke("test")
+
+    async def test_iql_tool_returns_error_string(self) -> None:
+        kg = _mock_kg(columns=["error"], rows=[["Unknown relation 'foo'"]])
+        tool = InputLayerIQLTool(kg=kg)
+        result = await tool.ainvoke("?foo(X)")
+        assert "Error:" in result
+        assert "Unknown relation" in result
+
+    async def test_iql_tool_handles_empty_error_row(self) -> None:
+        kg = _mock_kg(columns=["error"], rows=[[]])
+        tool = InputLayerIQLTool(kg=kg)
+        result = await tool.ainvoke("?bad(X)")
+        assert "Error:" in result
+        assert "unknown error" in result
+
+    async def test_iql_tool_handles_none_error_cell(self) -> None:
+        """An error envelope carrying a None cell should not crash."""
+        kg = _mock_kg(columns=["error"], rows=[[None]])
+        tool = InputLayerIQLTool(kg=kg)
+        result = await tool.ainvoke("?bad(X)")
+        assert "Error:" in result
+        assert "unknown error" in result
+
+    async def test_structured_tool_handles_empty_error_row(self) -> None:
+        """Structured tool path must guard the same edge as the IQL tool."""
+        kg = _mock_kg(columns=["error"], rows=[[]])
+        tool = tools_from_relations(kg, [_Employee])[0]
+        out = await tool.ainvoke({"department": "eng"})
+        payload = json.loads(out)
+        assert payload == {"error": "unknown error"}
+
+    async def test_structured_tool_handles_no_rows_error(self) -> None:
+        """Error response with an empty rows list must not crash."""
+        kg = _mock_kg(columns=["error"], rows=[])
+        tool = tools_from_relations(kg, [_Employee])[0]
+        out = await tool.ainvoke({"department": "eng"})
+        payload = json.loads(out)
+        assert payload == {"error": "unknown error"}
+
+
+class TestNoneAndEdgeValues:
+    """None values and edge cases in results should be handled gracefully."""
+
+    async def test_retriever_none_in_content_column(self) -> None:
+        """None content values should be skipped, not rendered as 'None'."""
+        kg = _mock_kg(
+            columns=["title", "content"],
+            rows=[["Doc1", None]],
+        )
+        r = InputLayerRetriever(
+            kg=kg,
+            query="?docs(T, C)",
+            page_content_columns=["content"],
+            metadata_columns=["title"],
+        )
+        docs = await r.ainvoke("test")
+        assert len(docs) == 1
+        assert docs[0].page_content == ""  # not "None"
+
+    async def test_retriever_all_none_content_columns(self) -> None:
+        """When all content columns are None, page_content should be empty."""
+        kg = _mock_kg(
+            columns=["title", "body", "summary"],
+            rows=[["Doc1", None, None]],
+        )
+        r = InputLayerRetriever(
+            kg=kg,
+            query="?docs(T, B, S)",
+            page_content_columns=["body", "summary"],
+            metadata_columns=["title"],
+        )
+        docs = await r.ainvoke("test")
+        assert docs[0].page_content == ""
+
+
+class TestMetadataValidation:
+    """Length mismatches in add_texts should be caught early."""
+
+    async def test_vectorstore_rejects_mismatched_metadatas(self) -> None:
+        from inputlayer.integrations.langchain import InputLayerVectorStore
+
+        kg = MagicMock()
+        kg.execute = AsyncMock(return_value=ResultSet(columns=[], rows=[]))
+        store = InputLayerVectorStore(
+            kg=kg,
+            relation=_make_vector_relation(),
+            embeddings=_StubEmbeddings(),
+        )
+        with pytest.raises(ValueError, match="Length mismatch"):
+            await store.aadd_texts(
+                ["text1", "text2", "text3"],
+                metadatas=[{"a": 1}],  # only 1 metadata for 3 texts
+            )
+
+    async def test_vectorstore_rejects_mismatched_ids(self) -> None:
+        from inputlayer.integrations.langchain import InputLayerVectorStore
+
+        kg = MagicMock()
+        kg.execute = AsyncMock(return_value=ResultSet(columns=[], rows=[]))
+        store = InputLayerVectorStore(
+            kg=kg,
+            relation=_make_vector_relation(),
+            embeddings=_StubEmbeddings(),
+        )
+        with pytest.raises(ValueError, match="Length mismatch"):
+            await store.aadd_texts(
+                ["text1", "text2"],
+                ids=["id1"],  # only 1 id for 2 texts
+            )
+
+
+def _make_vector_relation() -> type[Relation]:
+    """Create a minimal Relation with a vector column for testing."""
+    from inputlayer import Vector  # noqa: F401  # used in forward annotation
+
+    class TestDoc(Relation):
+        __relation_name__ = "test_doc"
+        id: str
+        content: str
+        embedding: Vector
+
+    return TestDoc