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

inputlayer_client_dev-0.1.0.dev915/LICENSE

@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. Please also get in touch with
+      us at legal@inputlayer.ai to let us know you're using the license.
+
+   Copyright 2024-2026 InputLayer
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+Copyright 2024-2026 InputLayer

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

@@ -1,8 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: inputlayer-client-dev
-Version: 0.1.0.dev912
+Version: 0.1.0.dev915
 Summary: Python Object-Logic Mapper for InputLayer knowledge graph engine
 License-Expression: Apache-2.0
+License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: pydantic<3,>=2.0
 Requires-Dist: websockets<15,>=12.0
@@ -572,4 +573,4 @@ uv run mypy src/inputlayer/
 
 ## License
 
-Apache 2.0 + Commons Clause. See [LICENSE](../../LICENSE).
+Apache 2.0. See [LICENSE](./LICENSE). (The InputLayer core server is separately licensed under the Elastic License 2.0.)

{inputlayer_client_dev-0.1.0.dev912 → inputlayer_client_dev-0.1.0.dev915}/README.md

@@ -539,4 +539,4 @@ uv run mypy src/inputlayer/
 
 ## License
 
-Apache 2.0 + Commons Clause. See [LICENSE](../../LICENSE).
+Apache 2.0. See [LICENSE](./LICENSE). (The InputLayer core server is separately licensed under the Elastic License 2.0.)

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "inputlayer-client-dev"
-version = "0.1.0.dev912"
+version = "0.1.0.dev915"
 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.dev915}/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.dev915}/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.dev915}/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.dev915}/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