lorebase-keeper 0.2.3__tar.gz → 0.3.1__tar.gz

lorebase_keeper-0.3.1/LICENSE

@@ -0,0 +1,201 @@
+                                 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 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 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 those 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. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Antonio Antenore
+
+   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.

lorebase_keeper-0.3.1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.5
+Name: lorebase-keeper
+Version: 0.3.1
+Summary: Lorebase Keeper: REST API service
+Project-URL: Homepage, https://github.com/aantenore/lorebase
+Project-URL: Documentation, https://aantenore.github.io/lorebase/
+Project-URL: Repository, https://github.com/aantenore/lorebase
+Project-URL: Changelog, https://github.com/aantenore/lorebase/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/aantenore/lorebase/issues
+Author: Antonio Antenore
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: knowledge-graph,mcp,ontology,postgres,versioning
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Requires-Python: >=3.12
+Requires-Dist: asyncpg>=0.29
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx>=0.27
+Requires-Dist: lorebase-core<0.4,>=0.3
+Requires-Dist: lorebase-platform<0.4,>=0.3
+Requires-Dist: lorebase-store<0.4,>=0.3
+Requires-Dist: opentelemetry-api>=1.25
+Requires-Dist: pgvector>=0.3
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyjwt[crypto]>=2.8
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: uvicorn>=0.30
+Provides-Extra: mssql
+Requires-Dist: pymssql>=2.3; extra == 'mssql'
+Provides-Extra: mysql
+Requires-Dist: asyncmy>=0.2.10; extra == 'mysql'
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=15; extra == 'parquet'
+Description-Content-Type: text/markdown
+
+# lorebase-keeper
+
+Part of [Lorebase](https://github.com/aantenore/lorebase), an open-source ontology platform: a versioned, governed knowledge graph on Postgres with git-like branching and three-way merge.
+
+Keeper, the REST API service of Lorebase: schema, records, branches, merges, Proposals, search and the read API agents use.
+
+```sh
+uv tool install lorebase-keeper    # or: pip install lorebase-keeper
+lorebase-keeper --help
+```
+
+Documentation: [Deployment](https://aantenore.github.io/lorebase/deployment/) and the [documentation site](https://aantenore.github.io/lorebase/). License: Apache-2.0.

lorebase_keeper-0.3.1/README.md

@@ -0,0 +1,12 @@
+# lorebase-keeper
+
+Part of [Lorebase](https://github.com/aantenore/lorebase), an open-source ontology platform: a versioned, governed knowledge graph on Postgres with git-like branching and three-way merge.
+
+Keeper, the REST API service of Lorebase: schema, records, branches, merges, Proposals, search and the read API agents use.
+
+```sh
+uv tool install lorebase-keeper    # or: pip install lorebase-keeper
+lorebase-keeper --help
+```
+
+Documentation: [Deployment](https://aantenore.github.io/lorebase/deployment/) and the [documentation site](https://aantenore.github.io/lorebase/). License: Apache-2.0.

lorebase_keeper-0.3.1/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "lorebase-keeper"
+version = "0.3.1"
+description = "Lorebase Keeper: REST API service"
+requires-python = ">=3.12"
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Antonio Antenore" }]
+keywords = ["ontology", "knowledge-graph", "mcp", "postgres", "versioning"]
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Database",
+]
+dependencies = [
+  "lorebase-core>=0.3,<0.4",
+  "lorebase-store>=0.3,<0.4",
+  "lorebase-platform>=0.3,<0.4",
+  "fastapi>=0.115",
+  "uvicorn>=0.30",
+  "pydantic>=2.7",
+  "opentelemetry-api>=1.25",
+  "asyncpg>=0.29",  # readiness probe of the database (imported lazily)
+  "pgvector>=0.3",  # vector column types of semantic search
+  "httpx>=0.27",
+  "PyJWT[crypto]>=2.8",
+  "python-multipart>=0.0.9",  # form parser of Starlette: file uploads of POST schema:infer
+]
+
+[project.optional-dependencies]
+parquet = ["pyarrow>=15"]  # Parquet uploads of POST schema:infer and schema:preview
+mysql = ["asyncmy>=0.2.10"]  # MySQL and MariaDB sources of POST schema:infer
+mssql = ["pymssql>=2.3"]  # SQL Server sources of POST schema:infer
+
+[project.scripts]
+lorebase-keeper = "lorebase_keeper.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/aantenore/lorebase"
+Documentation = "https://aantenore.github.io/lorebase/"
+Repository = "https://github.com/aantenore/lorebase"
+Changelog = "https://github.com/aantenore/lorebase/blob/main/CHANGELOG.md"
+Issues = "https://github.com/aantenore/lorebase/issues"
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lorebase_keeper"]

lorebase_keeper-0.3.1/src/lorebase_keeper/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{lorebase_keeper-0.2.3 → lorebase_keeper-0.3.1}/src/lorebase_keeper/agents/context.py

@@ -45,6 +45,7 @@ from lorebase_keeper.agents.pack import (
 from lorebase_keeper.agents.settings import ContextSettings
 from lorebase_keeper.reading.compiler import record_columns
 from lorebase_keeper.reading.history import REVISIONS
+from lorebase_keeper.reading.lenses import resolve_lens, trait_kinds
 from lorebase_keeper.reading.points import ReadPoint, not_found
 from lorebase_keeper.reading.problems import invalid
 from lorebase_keeper.reading.records import plan_query, require_kind, run_query
@@ -74,28 +75,77 @@ def timestamp(value: datetime | None) -> str | None:
 
 @dataclass(frozen=True, slots=True)
 class PackSettings:
+    """What a request asks for once its lens is applied (design 8.8): members of the request
+    win over the lens's, which win over the settings."""
+
     budget_tokens: int
     depth: int
+    include_schema: bool = True
+    include_recent_changes: bool = True
+    include_lineage: bool = True
+    relations: tuple[str, ...] = ()
+    """Relation ids of the lens, followed in both directions when the request names none."""
+    kinds: frozenset[str] | None = None
+    """Ids of the Kinds that neighbors and `search` and `query` seeds are limited to, from the
+    request's `traits` or else the lens; `None`: no limit."""
+    capped: bool = False
+    """A budget or depth of the lens was over the configured bounds and is served at them."""
 
 
 def effective(
-    request: ContextRequest, settings: ContextSettings, runtime: ReadRuntime
+    request: ContextRequest,
+    settings: ContextSettings,
+    runtime: ReadRuntime,
+    point: ReadPoint,
 ) -> PackSettings:
-    """Budget and depth of a request, within the configured bounds (422 otherwise)."""
-    budget = request.budget_tokens or settings.default_budget_tokens
-    if budget > settings.max_budget_tokens:
+    """Budget, depth, sections and Kinds of a request: its own members, else those of its
+    lens, else the settings. Values of the request over the configured bounds are 422; those
+    of a lens are served at the bounds (the pack says `capped`)."""
+    resolved = None if request.lens is None else resolve_lens(point, request.lens, "/body/lens")
+    lens = None if resolved is None else resolved.lens
+    capped = False
+    budget = request.budget_tokens
+    if budget is None:
+        budget = (lens.budget_tokens if lens else None) or settings.default_budget_tokens
+        if budget > settings.max_budget_tokens:
+            budget, capped = settings.max_budget_tokens, True
+    elif budget > settings.max_budget_tokens:
         raise invalid(
             "/body/budget_tokens", f"must not exceed {settings.max_budget_tokens}", "limit_exceeded"
         )
-    depth = settings.default_depth if request.depth is None else request.depth
     deepest = min(
         settings.max_depth,
         runtime.read.traverse.max_depth,
         runtime.store_settings.traverse.max_depth,
     )
-    if depth > deepest:
+    depth = request.depth
+    if depth is None:
+        depth = settings.default_depth if lens is None or lens.depth is None else lens.depth
+        if depth > deepest:
+            depth, capped = deepest, True
+    elif depth > deepest:
         raise invalid("/body/depth", f"must not exceed {deepest}", "limit_exceeded")
-    return PackSettings(budget, depth)
+    kinds: frozenset[str] | None = None
+    if request.traits is not None:
+        kinds = frozenset(k.id for k in trait_kinds(point, request.traits, "/body/traits"))
+    elif resolved is not None and resolved.kinds is not None:
+        kinds = frozenset(k.id for k in resolved.kinds)
+
+    def section(asked: bool | None, preset: bool | None) -> bool:
+        return asked if asked is not None else True if preset is None else preset
+
+    return PackSettings(
+        budget,
+        depth,
+        include_schema=section(request.include_schema, lens.include_schema if lens else None),
+        include_recent_changes=section(
+            request.include_recent_changes, lens.include_recent_changes if lens else None
+        ),
+        include_lineage=section(request.include_lineage, lens.include_lineage if lens else None),
+        relations=lens.relations if lens else (),
+        kinds=kinds,
+        capped=capped,
+    )
 
 
 # Seeds ----------------------------------------------------------------------------------------
@@ -107,8 +157,10 @@ async def seed_addresses(
     point: ReadPoint,
     request: ContextRequest,
     settings: ContextSettings,
+    kinds: frozenset[str] | None = None,
 ) -> list[tuple[Kind, str]]:
-    """`(Kind, key)` of the seeds, in request, query or ranking order, without repeats."""
+    """`(Kind, key)` of the seeds, in request, query or ranking order, without repeats.
+    `kinds` (ids) limits the Kinds of `query` and `search` seeds, never those of `refs`."""
     cap = settings.max_seeds
     found: list[tuple[str, str]] = []
     if request.refs is not None:
@@ -129,11 +181,23 @@ async def seed_addresses(
             session, runtime, point, plan, shape="context", cursor_pointer="/body/query/cursor"
         )
         found = [(item.kind, item.key) for item in page.items]
+        if kinds is not None:
+            allowed = {point.schema.kinds[k].api_name for k in kinds if k in point.schema.kinds}
+            found = [(kind, key) for kind, key in found if kind in allowed]
     else:
         assert request.search is not None
         limit = min(cap, runtime.search.results.max_limit)
         hits = await search(
-            session, runtime, point, SearchRequest(q=request.search, mode="lexical", limit=limit)
+            session,
+            runtime,
+            point,
+            SearchRequest(
+                q=request.search,
+                mode="lexical",
+                limit=limit,
+                traits=request.traits,
+                lens=request.lens,
+            ),
         )
         found = [(hit.kind, hit.key) for hit in hits.items]
     unique = list(dict.fromkeys(found))
@@ -203,8 +267,9 @@ async def surroundings(
     seeds: Sequence[RecordOut],
     request: ContextRequest,
     settings: ContextSettings,
-    depth: int,
+    bounds: PackSettings,
 ) -> Surroundings:
+    depth = bounds.depth
     if depth == 0 or not seeds:
         return Surroundings((), (), False)
     caps, walk = runtime.read.traverse, runtime.store_settings.traverse
@@ -216,7 +281,7 @@ async def surroundings(
             point.schema,
             [(require_kind(point, s.kind).id, s.key) for s in seeds],
             depth=depth,
-            follow=_follow(point, request.relations),
+            follow=_follow(point, request.relations, bounds),
             max_nodes=min(len(seeds) + settings.max_neighbors, caps.max_nodes, walk.max_nodes),
             max_links=max(min(settings.max_links, caps.max_edges, walk.max_links), 1),
             runtime=runtime.store,
@@ -264,14 +329,20 @@ async def surroundings(
     return Surroundings(tuple(neighbors), ordered_links, found.truncated)
 
 
-def _follow(point: ReadPoint, names: list[str] | None) -> dict[str, Direction]:
+def _follow(
+    point: ReadPoint, names: list[str] | None, bounds: PackSettings | None = None
+) -> dict[str, Direction]:
     """Relations to walk (id to direction): those named (forward or inverse api name; default:
-    all), in the directions named, between Kinds the caller may read."""
+    those of the lens, else all), in the directions named, between Kinds the caller may read.
+    With `bounds.kinds`, a direction is walked only when it reaches a Kind of that set, so
+    other Kinds are neither returned nor walked through."""
     schema = point.schema
     wanted: dict[str, set[LinkDirection]] = defaultdict(set)
     if names is None:
+        lens_relations = () if bounds is None else bounds.relations
         for relation in schema.relations.values():
-            wanted[relation.id] = set(LinkDirection)
+            if not lens_relations or relation.id in lens_relations:
+                wanted[relation.id] = set(LinkDirection)
     else:
         for index, name in enumerate(names):
             found = schema.relation_by_api_name(name)
@@ -284,6 +355,14 @@ def _follow(point: ReadPoint, names: list[str] | None) -> dict[str, Direction]:
         ends = (schema.kinds.get(relation.from_kind), schema.kinds.get(relation.to_kind))
         if any(kind is None or not point.scope.allows(kind.api_name) for kind in ends):
             continue  # Kinds the caller may not read are neither returned nor walked through
+        if bounds is not None and bounds.kinds is not None:
+            reached = {
+                LinkDirection.FORWARD: relation.to_kind,
+                LinkDirection.INVERSE: relation.from_kind,
+            }
+            directions = {d for d in directions if reached[d] in bounds.kinds}
+            if not directions:
+                continue
         if len(directions) == 2:
             follow[relation_id] = Direction.BOTH
         else:
@@ -444,14 +523,14 @@ async def build_pack(
     settings: ContextSettings,
 ) -> tuple[bytes, str]:
     """The rendered pack and its media type."""
-    bounds = effective(request, settings, runtime)
+    bounds = effective(request, settings, runtime, context.point)
     point = await with_rows(session, runtime, context.point, "Context packs")
-    addresses = await seed_addresses(session, runtime, point, request, settings)
+    addresses = await seed_addresses(session, runtime, point, request, settings, bounds.kinds)
     rows = await fetch_rows(session, point, addresses)
     seeds = [record_out(point.schema, row, masking=point.masking) for row in rows]
-    around = await surroundings(session, runtime, point, seeds, request, settings, bounds.depth)
+    around = await surroundings(session, runtime, point, seeds, request, settings, bounds)
     changes = None
-    if request.include_recent_changes:
+    if bounds.include_recent_changes:
         records = list(addresses)
         for neighbor in around.neighbors:
             kind = point.schema.kind_by_api_name(neighbor.kind)
@@ -465,9 +544,7 @@ async def build_pack(
             floor=context.floor,
             limit=settings.recent_changes_max,
         )
-    lineage = (
-        await lineage_items(session, runtime, point, rows) if request.include_lineage else None
-    )
+    lineage = await lineage_items(session, runtime, point, rows) if bounds.include_lineage else None
     draft = Draft(
         seeds=tuple(
             SeedItem(
@@ -481,7 +558,7 @@ async def build_pack(
         ),
         neighbors=around.neighbors,
         links=around.links,
-        schema=request.include_schema,
+        schema=bounds.include_schema,
         changes=changes,
         lineage=lineage,
     )
@@ -499,7 +576,7 @@ async def build_pack(
         draft,
         budget_tokens=bounds.budget_tokens,
         chars_per_token=settings.chars_per_token,
-        capped=around.capped,
+        capped=around.capped or bounds.capped,
     )
     if markdown:
         # References are resolved when the pack is sent, from the envelope (never by

{lorebase_keeper-0.2.3 → lorebase_keeper-0.3.1}/src/lorebase_keeper/agents/pack.py

@@ -56,11 +56,28 @@ class ContextRequest(BaseModel):
     depth: int | None = Field(default=None, ge=0, description="Neighborhood depth (0: none).")
     relations: list[str] | None = Field(
         default=None,
-        description="Relation api names to follow (forward or inverse); default: all.",
+        description="Relation api names to follow (forward or inverse); default: all, or the "
+        "Relations of `lens`.",
+    )
+    traits: list[str] | None = Field(
+        default=None,
+        description="Trait api names: with `search` or `query` seeds, only Records of the "
+        "Kinds implementing them (that the caller may read) become seeds, and only Records of "
+        "those Kinds are neighbors. Seeds named by `refs` are always kept.",
+    )
+    lens: str | None = Field(
+        default=None,
+        description="Lens api name (a read preset of the schema): its Relations, depth, "
+        "sections and budget are the defaults of this request, its Kinds and Traits limit "
+        "neighbors and `search` and `query` seeds like `traits`. Members given here win.",
+    )
+    include_schema: bool | None = Field(default=None, description="Default: the lens's, else true.")
+    include_recent_changes: bool | None = Field(
+        default=None, description="Default: the lens's, else true."
+    )
+    include_lineage: bool | None = Field(
+        default=None, description="Default: the lens's, else true."
     )
-    include_schema: bool = True
-    include_recent_changes: bool = True
-    include_lineage: bool = True
     since: str | None = Field(
         default=None,
         description="Revision id or tag: recent changes after it; default: the latest changes.",
@@ -167,7 +184,10 @@ class BudgetOut(_Out):
     trimmed: list[TrimOut]
     omitted: dict[str, int] = Field(description="Entries removed to fit, per section.")
     over_budget: bool = Field(description="True when even the seed Records exceed the budget.")
-    capped: bool = Field(description="True when graph caps cut the neighborhood.")
+    capped: bool = Field(
+        description="True when graph caps cut the neighborhood, or a depth or budget of the "
+        "lens was served at the configured cap."
+    )
 
 
 class ContextPackOut(_Out):

{lorebase_keeper-0.2.3 → lorebase_keeper-0.3.1}/src/lorebase_keeper/app.py

@@ -45,6 +45,7 @@ from lorebase_keeper.readiness import (
     ReadinessCheck,
     ReplicaCheck,
     SearchBackendCheck,
+    VectorSearchCheck,
     default_checks,
     packaged_heads,
     run_checks,
@@ -187,6 +188,8 @@ def create_app(
         search_check = SearchBackendCheck(database.sessions, definer=definer)
         if readiness_checks is None:
             checks.append(search_check)
+    if database is not None and readiness_checks is None:
+        checks.append(VectorSearchCheck(database.sessions, search_settings(settings).semantic))
     store = auth_store or (database.auth_store if database else None)
     if keeper.auth.mode != "none" and store is None:
         raise ConfigError(
@@ -219,7 +222,7 @@ def create_app(
     traces = _trace_recorder(keeper.trace, database, trace_sink, telemetry)
 
     @asynccontextmanager
-    async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+    async def lifespan(application: FastAPI) -> AsyncIterator[None]:
         if search_check is not None:
             found = (await run_checks([search_check], keeper.readiness.timeout_s))[
                 search_check.name
@@ -229,6 +232,9 @@ def create_app(
         try:
             yield
         finally:
+            read_runtime = getattr(application.state, "read_runtime", None)
+            if read_runtime is not None and read_runtime.misses is not None:
+                await read_runtime.misses.aclose()
             if reads is not None:
                 await reads.aclose()
             if traces is not None: