vgi-python 0.39.0__tar.gz → 0.41.0__tar.gz

{vgi_python-0.39.0 → vgi_python-0.41.0}/.github/dependabot.yml

@@ -27,6 +27,14 @@ updates:
       # failing on an impossible update; the alerts stay visible in the
       # security tab. The real fix is lifting the cap upstream in vgi-rpc.
       - dependency-name: "aiohttp"
+      # The filter evaluator implements vgi.duckdb.standard.v1, pinned to
+      # DuckDB 1.5.5 / Haybarn 1.5.5-rc1 (vgi/filter_v2.py
+      # STANDARD_V1_ENGINE_VERSIONS); any other engine build refuses every
+      # pushed-down filter. Bumping them is a deliberate profile decision, not
+      # a routine update: locking duckdb 1.5.6 broke filter pushdown in the
+      # vgi integration suite.
+      - dependency-name: "duckdb"
+      - dependency-name: "haybarn"
 
   # GitHub Actions used by the workflows in .github/workflows/.
   - package-ecosystem: "github-actions"

{vgi_python-0.39.0 → vgi_python-0.41.0}/.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
@@ -53,7 +53,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Install dependencies
         run: uv sync --all-extras
@@ -89,7 +89,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Set up Python 3.14
         run: uv python install 3.14
@@ -112,7 +112,7 @@ jobs:
       # fail_on_error to true (and drop continue-on-error) once the vocab in
       # .github/styles/config/vocabularies/VGI/accept.txt is settled.
       - name: Prose lint (Vale)
-        uses: errata-ai/vale-action@v2
+        uses: errata-ai/vale-action@v3
         continue-on-error: true
         with:
           files: docs
@@ -126,6 +126,27 @@ jobs:
           args: "--no-progress --offline --root-dir ${{ github.workspace }}/docs docs/**/*.md *.md"
           fail: true
 
+  hosted-protocols:
+    # vgi-rpc's cross-SDK hosted-protocols group: the fixture workers must host
+    # vgi.v2 then conformance.Secondary.v1 on stdio, unix and HTTP, and pass the
+    # Identity.v1 groups over HTTP (vgi-fixture-http --identity).
+    name: Hosted-protocols conformance
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v10.2.0
+
+      - name: Set up Python 3.14
+        run: uv python install 3.14
+
+      - name: Install dependencies
+        run: uv sync --all-extras --python 3.14
+
+      - name: Run hosted-protocols group (stdio, unix, http)
+        run: scripts/hosted_protocols_conformance.sh
+
   s3-offload-localstack:
     name: S3 Offload Tests (LocalStack)
     runs-on: ubuntu-latest
@@ -147,7 +168,7 @@ jobs:
           path: vgi-rpc
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Set up Python 3.14
         run: uv python install 3.14

{vgi_python-0.39.0 → vgi_python-0.41.0}/.github/workflows/docs.yml

@@ -18,7 +18,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Set up Python
         run: uv python install 3.14

{vgi_python-0.39.0 → vgi_python-0.41.0}/.github/workflows/integration.yml

@@ -73,7 +73,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Set up Python 3.14
         run: uv python install 3.14

{vgi_python-0.39.0 → vgi_python-0.41.0}/.github/workflows/release.yml

@@ -33,7 +33,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Build vgi (sdist + wheel)
         run: uv build --sdist --wheel --out-dir dist-vgi .

{vgi_python-0.39.0 → vgi_python-0.41.0}/CLAUDE.md

@@ -428,9 +428,10 @@ caller's identity before it can authorize anything.
 
 Through vgi-rpc 0.45.x this was an HTTP JSON route, `POST
 {prefix}/__introspect_token__`, which meant it existed on exactly one
-transport. As of **vgi-rpc 0.46.0** identity lives at the RPC layer, so it
-reaches every transport, and a client discovers it through ordinary reflection
-(`list_protocols`) rather than by calling and reading an error.
+transport. As of **vgi-rpc 0.46.0** identity lives at the RPC layer, and a
+client discovers it through ordinary reflection (`list_protocols`) rather than
+by calling and reading an error. VGI hosts it on HTTP only — the transport that
+authenticates callers (see `build_rpc_server` in `vgi/rpc_server.py`).
 
 ```python
 from vgi.auth import AuthUnavailableError, TokenIdentity
@@ -469,7 +470,10 @@ credentials. Throttle untrusted traffic at the proxy, per client.
 
 Return `None` for "the store answered and this credential is unknown"; raise
 `AuthUnavailableError` for "the answer is not knowable". A caller that
-negative-caches the first must not cache the second. Never return claims — a
+negative-caches the first must not cache the second. Raising the same error
+an authenticator raises is correct here: vgi-rpc translates an
+`AuthUnavailableError` from either identity hook into `identity_unavailable`
+(code `UNAVAILABLE`) and carries its `retry_after` as `RetryInfo`. Never return claims — a
 pass-through claims field would let a worker choose its caller's tenant routing
 and policy branch.
 
@@ -480,6 +484,26 @@ sidecar outage raised as one is read as "not my credential, try the next" and
 ends up a 401 from the end of the chain, restarting every session in the fleet
 over a thirty-second blip.
 
+### Hosting Additional Protocols (`hosted_protocols`)
+
+Every transport (stdio, unix/named pipe, TCP, Iroh, HTTP) builds its `RpcServer`
+through one helper, `build_rpc_server(worker, *, transport, ...)` in
+`vgi/rpc_server.py`. Never call `RpcServer(...)` for a worker anywhere else.
+`tests/test_hosted_protocols.py` enforces this structurally. Only
+`vgi/secret_service.py` and `vgi/transactor/server.py` are exempt, because they
+serve other protocols.
+
+A worker hosts extra vgi-rpc protocols by overriding the classmethod
+`Worker.hosted_protocols() -> Sequence[tuple[type, object]]` (empty by
+default). It is called once per server build. Its pairs are hosted on every
+transport, after `vgi.v2` and before `vgi_rpc.Reflection.v1`, which is now
+hosted on every transport too. You cannot host part of a protocol: the
+protocol is the unit of optionality. Duplicate names, `vgi.v2` itself, and the
+reserved `vgi_rpc.` prefix all fail at startup with an error that names the
+hook. `MetaWorker` hosts its children's lists concatenated. Identity is not
+supplied through this hook. It stays opt-in via `resolve_token`/`mint_grant`
+and is hosted on HTTP only. See `docs/api/worker.md`.
+
 ### Access Log Sampling and Async Emission
 
 `--access-log-sample 0.05` keeps 5% of *successful* calls. Errors are always
@@ -606,6 +630,28 @@ This allows workers to expose structured metadata (tables, views, functions) to
 The recommended pattern is to back tables with `TableFunctionGenerator` functions.
 The table schema is automatically derived from the function's `output_schema`:
 
+### catalog_contents (whole-catalog load, protocol 2.1.0)
+
+`Worker.catalog_contents(attach_opaque_data, if_none_match=None)` returns
+`CatalogContentsResponse{catalog_version, etag, not_modified, schemas: list<struct SchemaContents>}`
+(`path` first, then the `SchemaInfo` item and eight `list<binary>` kinds, items
+byte-identical to the per-schema RPCs). The catalog side is
+`CatalogInterface.catalog_contents(*, attach_opaque_data, if_none_match) -> CatalogContentsResult`.
+The worker validates paths, orders parents first and enforces the etag rules
+(`not_modified` only with an etag equal to `if_none_match`). Opt-ins:
+`catalog_contents_etag = "content-hash"` (framework SHA-256 etag) and
+`catalog_contents_attach_independent` (with `catalog_version_frozen`, the worker
+caches the serialized response per catalog version; `ReadOnlyCatalogInterface`
+sets it). Fixture catalogs: `vgi/_test_fixtures/catalog_contents.py`
+(`contents_probe/broken/legacy/memory/reval/hash`). Every SDK's fixture worker
+serves the same six catalogs: the extension's five `catalog_contents*.test` files
+run against all of them (no `VGI_CATALOG_CONTENTS_WORKER` gate any more), so these
+semantics are the cross-SDK contract. Client side, `Client.load_catalog(attach=,
+previous=)` is the whole-catalog enumeration: `catalog_contents` only when
+advertised, per-schema fallback on failure / in a transaction, `if_none_match`
+revalidation via `previous` (`tests/catalog/test_client_load_catalog.py`). See
+`docs/catalog-interface.md`.
+
 ## Additional Documentation
 
 - **Access log**: See `vgi-rpc` docs site

{vgi_python-0.39.0 → vgi_python-0.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.39.0
+Version: 0.41.0
 Summary: Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow
 Project-URL: Homepage, https://query.farm
 Project-URL: Repository, https://github.com/Query-farm/vgi-python
@@ -162,13 +162,13 @@ Requires-Dist: httpx2>=2.12.0
 Requires-Dist: platformdirs
 Requires-Dist: pyarrow
 Requires-Dist: typer>=0.9
-Requires-Dist: vgi-rpc>=0.47.2
+Requires-Dist: vgi-rpc>=0.48.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.16.0; extra == 'azure'
 Requires-Dist: pymssql>=2.3.0; extra == 'azure'
 Provides-Extra: dev
 Requires-Dist: azure-identity>=1.16.0; extra == 'dev'
-Requires-Dist: duckdb>=1.5.3; extra == 'dev'
+Requires-Dist: duckdb==1.5.5; extra == 'dev'
 Requires-Dist: jsonschema; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: numpy>=2.4.1; extra == 'dev'
@@ -188,14 +188,14 @@ Requires-Dist: vgi-rpc[oauth]; extra == 'dev'
 Requires-Dist: vgi-rpc[otel]; extra == 'dev'
 Requires-Dist: vgi-rpc[sentry]; extra == 'dev'
 Provides-Extra: duckdb
-Requires-Dist: duckdb>=1.5.3; extra == 'duckdb'
+Requires-Dist: duckdb==1.5.5; extra == 'duckdb'
 Provides-Extra: fixtures
 Requires-Dist: vgi-fixtures; extra == 'fixtures'
 Provides-Extra: granian
 Requires-Dist: granian>=2.7; extra == 'granian'
 Requires-Dist: vgi-rpc[http]; extra == 'granian'
 Provides-Extra: haybarn
-Requires-Dist: haybarn>=1.5.5rc1; extra == 'haybarn'
+Requires-Dist: haybarn==1.5.5rc1; extra == 'haybarn'
 Provides-Extra: http
 Requires-Dist: vgi-rpc[http]; extra == 'http'
 Provides-Extra: iroh

{vgi_python-0.39.0 → vgi_python-0.41.0}/docs/api/auth.md

@@ -19,8 +19,9 @@ require `pip install vgi-python[http]`; JWT authentication additionally requires
 re-exports it — a worker that implements `resolve_token` never has to name a private import path.
 
 As of vgi-rpc 0.46.0 introspection is the `vgi_rpc.Identity.v1` protocol hosted on the RPC server,
-not an HTTP JSON route, so it reaches every transport rather than only HTTP. `TokenIdentity` and
-`TokenResolver` are correspondingly no longer gated on the `[http]` extra.
+not an HTTP JSON route, so clients discover it through reflection. VGI hosts it on HTTP only, the
+transport that authenticates callers: its allowlist names principals, which stdin/stdout, AF_UNIX
+and TCP do not have. `TokenIdentity` and `TokenResolver` are no longer gated on the `[http]` extra.
 
 ## Secret protocol
 

vgi_python-0.41.0/docs/api/worker.md

@@ -0,0 +1,99 @@
+# Worker & Serving
+
+A `Worker` hosts your functions (and optional catalog) in a separate process. It speaks the VGI
+protocol over Arrow IPC — either stdin/stdout (subprocess transport) or HTTP. The `vgi-serve`
+CLI (`vgi.serve`) is the zero-boilerplate entry point for running one.
+
+```python
+from vgi import Worker, ScalarFunction
+
+class MyWorker(Worker):
+    functions = [MyScalarFunction()]
+
+# vgi-serve my_module:MyWorker            # stdio
+# vgi-serve my_module:MyWorker --http     # HTTP
+```
+
+## Hosting additional protocols
+
+A worker can serve other [vgi-rpc](https://vgi-rpc.query.farm) protocols from the same process and
+the same listener as the VGI protocol. Override
+[`Worker.hosted_protocols`][vgi.worker.Worker.hosted_protocols] to return
+`(protocol, implementation)` pairs:
+
+```python
+from collections.abc import Sequence
+from typing import ClassVar, Protocol
+
+from vgi import Worker
+
+
+class Audit(Protocol):
+    protocol_name: ClassVar[str] = "acme.Audit.v1"
+
+    def record(self, event: str) -> int: ...
+
+
+class AuditImpl:
+    def record(self, event: str) -> int:
+        return len(event)
+
+
+class MyWorker(Worker):
+    functions = []
+
+    @classmethod
+    def hosted_protocols(cls) -> Sequence[tuple[type, object]]:
+        return [(Audit, AuditImpl())]
+```
+
+The rules:
+
+- **Every transport hosts the same list.** stdin/stdout, AF_UNIX (or a Windows named pipe), TCP,
+  the Iroh raw upstream and HTTP all build their server through one function,
+  [`build_rpc_server`][vgi.rpc_server.build_rpc_server].
+- **Called once per server.** The hook may read configuration or the environment, but its answer
+  is fixed for the life of the process, so reflection output and protocol hashes stay stable.
+- **The protocol is the unit of optionality.** There is no way to host part of a protocol. Make
+  an optional capability its own protocol, and include it or leave it out.
+- **Names are routing keys.** Each protocol needs a distinct `protocol_name`. A repeated name, the
+  worker's own `vgi.v2`, or the reserved `vgi_rpc.` prefix stops the worker at startup, and the
+  error names `hosted_protocols()`.
+- **`vgi.v2` is unaffected.** vgi-rpc routes each request on its `vgi_rpc.protocol` key and never
+  falls back to the primary protocol. A client that only speaks `vgi.v2`, such as the DuckDB
+  extension, sees exactly the behaviour it saw before.
+
+A `MetaWorker` (`vgi.meta_worker`) hosts the concatenation of its children's lists, in
+child order. Two children that list the same protocol name stop it at startup. Over HTTP it
+hosts Identity for the one child that overrides `resolve_token` or `mint_grant`; two children
+overriding the same hook stop it at startup.
+
+### What each transport hosts
+
+Reflection (`list_protocols`) reports protocols in this order:
+
+| Transport | `vgi.v2` | `hosted_protocols()` | `vgi_rpc.Reflection.v1` | `vgi_rpc.Identity.v1` |
+| --- | --- | --- | --- | --- |
+| stdin/stdout | yes | yes | yes | no |
+| AF_UNIX / named pipe | yes | yes | yes | no |
+| TCP | yes | yes | yes | no |
+| Iroh raw upstream | yes | yes | yes | no |
+| HTTP | yes | yes | unless `--no-describe` | when `resolve_token` or `mint_grant` is overridden |
+
+Identity stays framework-owned. You enable it by overriding
+[`resolve_token`][vgi.worker.Worker.resolve_token] or
+[`mint_grant`][vgi.worker.Worker.mint_grant], never through `hosted_protocols()`. It is hosted
+only on HTTP, which authenticates callers. Its introspection allowlist names principals, and the
+other transports have no principals to check.
+
+## Worker
+
+::: vgi.worker
+
+## Server construction
+
+::: vgi.rpc_server
+
+## Serving
+
+::: vgi.serve

{vgi_python-0.39.0 → vgi_python-0.41.0}/docs/catalog-interface.md

@@ -243,6 +243,80 @@ class MyCatalog(CatalogInterface):
 | | `view_rename()` | `NotImplementedError` |
 | | `view_comment_set()` | `NotImplementedError` |
 | **Observability** | `loggable_attach_options()` | Returns `{}` (no options logged — see below) |
+| **Bulk load** | `catalog_contents()` | Composes `schemas()` + `schema_contents()` per kind; no etag (see below) |
+
+---
+
+## Loading the Whole Catalog: `catalog_contents`
+
+A client normally learns a catalog lazily: `catalog_schemas`, then one
+`catalog_schema_contents_*` call per schema and object kind. When the attach
+result sets `supports_catalog_contents` (`ReadOnlyCatalogInterface` does), the
+client may instead load everything with one `catalog_contents` RPC (protocol
+2.1.0):
+
+```text
+catalog_contents(attach_opaque_data: binary, if_none_match: utf8 nullable)
+  -> CatalogContentsResponse {
+       catalog_version: int64
+       etag:            utf8 nullable   -- null: the worker does not revalidate
+       not_modified:    bool            -- true: schemas is empty, keep what you have
+       schemas: list<struct<path: list<utf8>, schema: binary,
+                            tables, views, scalar_functions, aggregate_functions,
+                            table_functions, scalar_macros, table_macros,
+                            indexes: list<binary>>>   -- parents before children
+     }
+```
+
+Each struct row is one schema: `path` equals the `SchemaInfo.path` encoded in
+`schema`, and every item is byte-identical to what the matching per-schema RPC
+returns. There is no transaction parameter: it is the committed catalog at
+`catalog_version`.
+
+`CatalogInterface.catalog_contents(*, attach_opaque_data, if_none_match=None)`
+returns a `CatalogContentsResult(schemas, etag=None, not_modified=False)`. The
+default composes `schemas()` and `schema_contents()` for every kind (skipping
+kinds whose `estimated_object_count` is exactly 0) and returns no etag.
+
+**Revalidation.** Return an `etag` to let a client revalidate a non-frozen
+catalog with `if_none_match` instead of re-downloading it. Check it *before*
+building, so an unchanged catalog costs almost nothing:
+
+```python test="lint"
+from vgi.catalog import CatalogContentsResult, CatalogInterface
+
+
+class GenerationCatalog(CatalogInterface):  # other methods omitted
+    generation = 1  # bumped by every DDL
+
+    def catalog_contents(self, *, attach_opaque_data, if_none_match=None):
+        etag = f"gen-{self.generation}"
+        if if_none_match == etag:
+            return CatalogContentsResult(etag=etag, not_modified=True)  # nothing built
+        full = super().catalog_contents(attach_opaque_data=attach_opaque_data)
+        return CatalogContentsResult(schemas=full.schemas, etag=etag)
+```
+
+The worker enforces the rules: `not_modified` requires an etag equal to
+`if_none_match` and no schemas; a full answer whose etag equals
+`if_none_match` is turned into `not_modified`; a catalog with no etag always
+answers in full (it ignores `if_none_match`).
+
+**Content-hash etag.** A catalog without a cheap validator can set
+`catalog_contents_etag = "content-hash"`: when it returns no etag, the worker
+uses the hex SHA-256 of the serialized snapshot. The worker still builds the
+snapshot on every call, but an unchanged catalog skips the transfer and the
+client's decode. It is off by default, because for a non-frozen catalog the
+client would revalidate with a full build on every transaction instead of a
+cheap `catalog_version` poll.
+
+**Worker cache.** When the catalog's version is frozen
+(`catalog_version_frozen`) and its contents do not depend on the attach or the
+caller (`catalog_contents_attach_independent = True`, the
+`ReadOnlyCatalogInterface` default), the worker builds the response once per
+catalog version and serves the same pre-serialized bytes to every call. A
+`ReadOnlyCatalogInterface` subclass whose contents vary per caller must set
+`catalog_contents_attach_independent = False`.
 
 ---
 
@@ -623,6 +697,14 @@ for obj in client.schema_contents(attach_opaque_data=attach_opaque_data, path=["
     elif isinstance(obj, FunctionInfo):
         print(f"Function: {obj.name}")
 
+# Or load the whole catalog at once. Uses one catalog_contents RPC when the
+# attach result advertises supports_catalog_contents, else the per-schema RPCs.
+snapshot = client.load_catalog(attach=result)
+for entry in snapshot.schemas:
+    print(entry.schema.path, [t.name for t in entry.tables])
+# Later: revalidate. A not_modified answer returns the same content cheaply.
+snapshot = client.load_catalog(attach=result, previous=snapshot)
+
 # Get only scalar functions using type filter
 from vgi.catalog import SchemaObjectType
 for obj in client.schema_contents(
@@ -649,6 +731,8 @@ client.catalog_detach(attach_opaque_data=attach_opaque_data)
 | `schema_create()` | Create a schema |
 | `schema_drop()` | Drop a schema |
 | `schema_contents()` | List schema contents (optional `type` filter) |
+| `load_catalog()` | Load the whole catalog: one `catalog_contents` call when the attach advertises it, else (or on failure, or inside a transaction) `catalog_schemas` + the per-schema RPCs; pass `previous=` to revalidate with `if_none_match` |
+| `contents()` | The raw `catalog_contents` RPC (only valid when advertised; `if_none_match` revalidates) |
 | `table_get()` | Get table info |
 | `table_create()` | Create a table |
 | `table_drop()` | Drop a table |

{vgi_python-0.39.0 → vgi_python-0.41.0}/packages/vgi-fixtures/pyproject.toml

@@ -34,7 +34,9 @@ classifiers = [
 # The fixture worker also builds statistics fixtures at import time, which
 # needs a DuckDB-compatible engine — vgi[duckdb] keeps the default dev env on
 # stock duckdb (the resolver prefers haybarn whenever it is installed too).
-dependencies = ["vgi-python[test-fixtures-writable]", "vgi-python[duckdb]"]
+# vgi-rpc is named directly because the fixture worker imports its conformance
+# fixtures (vgi_rpc.conformance.secondary, .identity_fixture), new in 0.48.0.
+dependencies = ["vgi-python[test-fixtures-writable]", "vgi-python[duckdb]", "vgi-rpc>=0.48.0"]
 
 [project.scripts]
 vgi-fixture-worker = "vgi._test_fixtures.worker:main"

{vgi_python-0.39.0 → vgi_python-0.41.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.39.0"
+version = "0.41.0"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [
@@ -40,7 +40,7 @@ dependencies = [
     "pyarrow",
     "typer>=0.9",
     "platformdirs",
-    "vgi-rpc>=0.47.2",
+    "vgi-rpc>=0.48.0",
     "httpx2>=2.12.0",
 ]
 
@@ -49,8 +49,14 @@ dependencies = [
 # evaluation, the transactor, and the statistics fixtures. It is resolved
 # lazily in vgi/_duckdb.py: haybarn is preferred, stock duckdb is the
 # fallback. Neither is a hard dependency — install one via these extras.
-haybarn = ["haybarn>=1.5.5rc1"]
-duckdb = ["duckdb>=1.5.3"]
+# Both are pinned EXACTLY: expression-filter evaluation implements
+# vgi.duckdb.standard.v1, whose oracle is upstream DuckDB 1.5.5 (Haybarn
+# 1.5.5-rc1), and vgi/filter_v2.py refuses any other engine build
+# (STANDARD_V1_ENGINE_VERSIONS). A looser range lets a resolver pick e.g.
+# duckdb 1.5.6, and every pushed-down filter then fails to bind. Change these
+# only together with STANDARD_V1_ENGINE_VERSIONS (a test keeps them in step).
+haybarn = ["haybarn==1.5.5rc1"]
+duckdb = ["duckdb==1.5.5"]
 http = ["vgi-rpc[http]"]
 iroh = ["vgi-rpc[http,iroh]"]
 # transport="launch": vgi_rpc.launcher imports filelock unconditionally at
@@ -84,7 +90,7 @@ test-fixtures-writable = [
     "vgi-python[transactor]",
 ]
 dev = [
-    "duckdb>=1.5.3",
+    "duckdb==1.5.5",  # pinned with the `duckdb` extra above
     "mypy",
     "pyarrow-stubs",
     # pydoclint is intentionally NOT a project dependency: it pulls

vgi_python-0.41.0/scripts/hosted_protocols_conformance.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+#
+# Run vgi-rpc's hosted-protocols conformance group (vgi-rpc-test-hosted)
+# against this repo's fixture workers on all three transports it covers:
+#
+#   stdio  vgi-fixture-worker                       (MetaWorker.serve, pipe)
+#   unix   vgi-fixture-worker --unix <sock>         (the DuckDB launcher path)
+#   http   vgi-fixture-http --identity              (+ the Identity.v1 groups)
+#
+# Every worker must host, in order, vgi.v2 then conformance.Secondary.v1.
+#
+# Usage: scripts/hosted_protocols_conformance.sh [stdio|unix|http ...]
+# Default: all three. Runs from the project env (`uv run --no-sync`), which
+# must have vgi-rpc with the [http,conformance] extras (the dev group does).
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+EXPECT="vgi.v2,conformance.Secondary.v1"
+RUN=(uv run --no-sync)
+BIN="$(dirname "$("${RUN[@]}" python -c 'import sys; print(sys.executable)')")"
+TRANSPORTS=("$@")
+[ ${#TRANSPORTS[@]} -eq 0 ] && TRANSPORTS=(stdio unix http)
+
+# Short scratch dir: AF_UNIX paths are capped at ~104 bytes, and CI temp
+# dirs can be long.
+SCRATCH="$(mktemp -d /tmp/vgihp.XXXXXX)"
+PIDS=()
+cleanup() {
+  for pid in "${PIDS[@]}"; do kill "$pid" 2>/dev/null || true; done
+  rm -rf "$SCRATCH"
+}
+trap cleanup EXIT
+
+wait_for() {  # wait_for <description> <test command...>
+  local what="$1"; shift
+  for _ in $(seq 150); do "$@" && return 0; sleep 0.2; done
+  echo "timed out waiting for $what" >&2
+  return 1
+}
+
+run_stdio() {
+  echo "== hosted-protocols: stdio =="
+  "${RUN[@]}" vgi-rpc-test-hosted --cmd "$BIN/vgi-fixture-worker" --expect "$EXPECT" -- -rs
+}
+
+run_unix() {
+  echo "== hosted-protocols: unix =="
+  local sock="$SCRATCH/w.sock"
+  "$BIN/vgi-fixture-worker" --unix "$sock" --idle-timeout 300 >"$SCRATCH/unix.out" 2>"$SCRATCH/unix.err" &
+  PIDS+=($!)
+  wait_for "unix socket $sock" test -S "$sock" || { cat "$SCRATCH/unix.err" >&2; return 1; }
+  "${RUN[@]}" vgi-rpc-test-hosted --unix "$sock" --expect "$EXPECT" -- -rs
+}
+
+run_http() {
+  echo "== hosted-protocols: http (--identity) =="
+  local port
+  port="$("${RUN[@]}" python -c 'import socket; s = socket.socket(); s.bind(("127.0.0.1", 0)); print(s.getsockname()[1])')"
+  "$BIN/vgi-fixture-http" --identity --host 127.0.0.1 --port "$port" >"$SCRATCH/http.out" 2>"$SCRATCH/http.err" &
+  PIDS+=($!)
+  wait_for "HTTP worker on :$port" curl -sf -o /dev/null "http://127.0.0.1:$port/health" \
+    || { cat "$SCRATCH/http.err" >&2; return 1; }
+  "${RUN[@]}" vgi-rpc-test-hosted --url "http://127.0.0.1:$port" --expect "$EXPECT" --identity -- -rs
+}
+
+for t in "${TRANSPORTS[@]}"; do
+  case "$t" in
+    stdio) run_stdio ;;
+    unix) run_unix ;;
+    http) run_http ;;
+    *) echo "unknown transport: $t (expected stdio, unix or http)" >&2; exit 2 ;;
+  esac
+done

{vgi_python-0.39.0 → vgi_python-0.41.0}/scripts/regen_generated.py

@@ -51,10 +51,13 @@ _TARGETS: list[tuple[str, str, str]] = [
         "vgi",
     ),
     ("vgi.codegen.go_schemas", "vgi/generated/protocol_schemas.go", "vgi-go"),
+    ("vgi.codegen.go_types", "vgi/generated/protocol_types.go", "vgi-go"),
     ("vgi.codegen.rust_schemas", "vgi-protocol/src/generated/protocol_schemas.rs", "vgi-rust"),
     ("vgi.codegen.rust_request_builders", "vgi-protocol/src/generated/request_params.rs", "vgi-rust"),
+    ("vgi.codegen.rust_types", "vgi-protocol/src/generated/protocol_types.rs", "vgi-rust"),
     ("vgi.codegen.ts_schemas", "src/generated/vgi-protocol-schemas.ts", "vgi-typescript"),
     ("vgi.codegen.ts_client", "src/generated/vgi-client.ts", "vgi-typescript"),
+    ("vgi.codegen.ts_types", "src/generated/vgi-protocol-types.ts", "vgi-typescript"),
     ("vgi.codegen.csharp_types", "src/QueryFarm.Vgi/Protocol/Generated/VgiProtocolTypes.g.cs", "vgi-csharp"),
     (
         "vgi.codegen.csharp_schemas",
@@ -68,6 +71,15 @@ _TARGETS: list[tuple[str, str, str]] = [
     ),
 ]
 
+# vgi-java's generated wire records: one file per record (Java allows one public
+# top-level type per file), so one target each. ``module:record`` tells
+# `_render` to call ``emit(out, record=...)``. Derived from the generator's own
+# list so adding a record there is all it takes.
+_TARGETS += [
+    (f"vgi.codegen.java_types:{record}", relative, "vgi-java")
+    for record, relative in importlib.import_module("vgi.codegen.java_types").targets()
+]
+
 
 def _repo_root(name: str) -> Path | None:
     """Locate a sibling checkout, or ``None`` when it is not present."""
@@ -79,10 +91,18 @@ def _repo_root(name: str) -> Path | None:
 
 
 def _render(module_name: str) -> str:
-    """Render one artifact into memory. Raises if the generator fails."""
+    """Render one artifact into memory. Raises if the generator fails.
+
+    ``module:record`` renders one file of a generator that emits several
+    (``emit(out, record=record)``).
+    """
+    module_name, _, record = module_name.partition(":")
     module = importlib.import_module(module_name)
     buf = io.StringIO()
-    module.emit(buf)
+    if record:
+        module.emit(buf, record=record)
+    else:
+        module.emit(buf)
     text = buf.getvalue()
     if not text.strip():
         raise RuntimeError(f"{module_name}.emit() produced no output")