@query-farm/vgi 0.42.0 → 0.44.0

package/src/http/fetch.ts

@@ -207,7 +207,7 @@ export function createVgiFetch(opts: VgiFetchOptions): (req: Request) => Promise
 
   // The same builder every other transport uses: `vgi.v2`, the worker's
   // hostedProtocols(), reflection, and -- HTTP being the transport that
-  // authenticates callers -- vgi_rpc.Identity.v1 when the worker opts in.
+  // authenticates callers -- vgi_rpc.Identity.v2 when the worker opts in.
   // Built at construction, so a worker that opts into introspection without an
   // allowlist fails here rather than serving traffic.
   const server = buildRpcServer(protocol, opts, {

package/src/index.core.ts

@@ -186,8 +186,10 @@ export {
   AttachTicketInvalidError,
   AttachTicketRequestError,
   SealAttachDeniedError,
+  type AttachTicket,
   type AttachTicketClaims,
   type RestoredAttach,
+  encodeAttachTicket,
   attachTicketAad,
   mintAttachTicket,
   openAttachTicket,
@@ -338,7 +340,7 @@ export { str, bytes, int, int32, float, float32, bool, toSchema, OutputCollector
 export { subprocessConnect, httpConnect, tcpConnect } from "@query-farm/vgi-rpc";
 export type { RpcClient, StreamSession, LogMessage } from "@query-farm/vgi-rpc";
 
-// Hosting additional protocols and opting into vgi_rpc.Identity.v1. The errors
+// Hosting additional protocols and opting into vgi_rpc.Identity.v2. The errors
 // are re-exported so a worker's resolveToken/mintGrant can throw the right one:
 // AuthUnavailableError (or IdentityUnavailableError) for "could not find out",
 // GrantRefusedError to decline a grant.

package/src/protocol/dispatch.ts

@@ -1,21 +1,23 @@
 // Copyright 2025, 2026 Query Farm LLC - https://query.farm
 // Build VGI protocol from worker implementation.
-// Orchestrator that registers function, aggregate, and catalog handlers
-// against vgi-rpc Protocol. The handler implementations live in handlers/.
+// The method table, its schemas and the UNIMPLEMENTED defaults are generated
+// (src/generated/vgi-service.ts, from vgi-python's VgiProtocol); this module
+// composes the handler groups in handlers/ over those defaults.
 
-import { Protocol } from "@query-farm/vgi-rpc";
+import type { Protocol } from "@query-farm/vgi-rpc";
 
-// NOTE: We must NOT use vgi-rpc's str/bytes/int/etc. singletons in Schema objects
-// because Bun loads apache-arrow as separate module instances for our code vs vgi-rpc's
-// compiled dist. Instead, we pre-build Schema objects and pass them directly to Protocol
-// methods (toSchema() passes Schema instances through without instanceof checks).
 import type { FunctionRegistry } from "../functions/registry.js";
 import type { CatalogInterface } from "../catalog/interface.js";
-import { registerFunctionMethods } from "./handlers/function.js";
-import { registerAggregateMethods } from "./handlers/aggregate.js";
-import { registerTableBufferingMethods } from "./handlers/table-buffering.js";
-import { registerCatalogMethods } from "./handlers/catalog/index.js";
-import { registerUnimplementedMethods } from "./handlers/unimplemented.js";
+import {
+  createVgiProtocol,
+  UNIMPLEMENTED_VGI_SERVICE,
+  VGI_PROTOCOL_NAME,
+  type VgiService,
+} from "../generated/vgi-service.js";
+import { functionHandlers } from "./handlers/function.js";
+import { aggregateHandlers } from "./handlers/aggregate.js";
+import { tableBufferingHandlers } from "./handlers/table-buffering.js";
+import { catalogHandlers } from "./handlers/catalog/index.js";
 
 export interface ProtocolConfig {
   registry: FunctionRegistry;
@@ -41,7 +43,8 @@ export interface ProtocolConfig {
  * That matters for this consumer specifically: the DuckDB extension ships to
  * users and cannot be flag-dayed.
  *
- * Declared rather than derived. Until the transports made the routing key
+ * Declared rather than derived, and now generated with the method table
+ * (src/generated/vgi-service.ts). Until the transports made the routing key
  * required, each implementation's wire name defaulted to whatever its local
  * type was called, which left the six ports disagreeing four ways — Python
  * `VgiProtocol`, Java and C# `VgiService`, Go the framework default `Service`,
@@ -55,15 +58,16 @@ export interface ProtocolConfig {
  * so the HTTP entry points build that scope from the same constant the
  * protocol is registered under rather than a second copy of the literal.
  */
-export const VGI_PROTOCOL_NAME = "vgi.v2";
+export { VGI_PROTOCOL_NAME };
 
 /**
  * The `vgi.v2` protocol hash `vgi_rpc.Reflection.v1` must report for this
  * worker: the reference's (vgi-python 0.43.0, 72 methods). Every SDK hosts
  * every `vgi.v2` method with the reference's schemas, so the hash is one value
  * across the ports; a method this SDK does not implement is still registered
- * (handlers/unimplemented.ts). The hash covers method names, types and the
- * params/result/header schemas only (WIRE_PROTOCOL.md §14).
+ * with the generated UNIMPLEMENTED default (src/generated/vgi-service.ts). The
+ * hash covers method names, types and the params/result/header schemas only
+ * (WIRE_PROTOCOL.md §14).
  *
  * It changes only with vgi.v2's protocol version (currently 2.1.0). Asserted
  * by src/protocol/__tests__/vgi-v2-hash.test.ts; if that test fails, the
@@ -71,18 +75,25 @@ export const VGI_PROTOCOL_NAME = "vgi.v2";
  */
 export const VGI_V2_PROTOCOL_HASH = "774cb80090d71ea76d09aa311b9cda4ca4c33c3bf72c43242eb6dc87b6f79ce5";
 
-export function buildVgiProtocol(config: ProtocolConfig): Protocol {
-  const protocol = new Protocol(VGI_PROTOCOL_NAME, { protocolVersion: "2.1.0" });
-
-  registerFunctionMethods(protocol, {
-    registry: config.registry,
-    signingKey: config.signingKey,
-    catalogInterface: config.catalogInterface,
-  });
-  registerAggregateMethods(protocol, config.registry);
-  registerTableBufferingMethods(protocol, config.registry, config.signingKey);
-  registerCatalogMethods(protocol, config.catalogInterface, config.catalogName, config.signingKey);
-  registerUnimplementedMethods(protocol);
+/**
+ * This worker's `vgi.v2` implementation: the generated UNIMPLEMENTED default
+ * for every method, overridden by the handler groups for what this SDK serves.
+ */
+export function buildVgiService(config: ProtocolConfig): VgiService {
+  return {
+    ...UNIMPLEMENTED_VGI_SERVICE,
+    ...functionHandlers({
+      registry: config.registry,
+      signingKey: config.signingKey,
+      catalogInterface: config.catalogInterface,
+    }),
+    ...aggregateHandlers(config.registry),
+    ...tableBufferingHandlers(config.registry, config.signingKey),
+    ...catalogHandlers(config.catalogInterface, config.signingKey),
+  };
+}
 
-  return protocol;
+/** The `vgi.v2` protocol, registered from the generated table with {@link buildVgiService}. */
+export function buildVgiProtocol(config: ProtocolConfig): Protocol {
+  return createVgiProtocol(buildVgiService(config));
 }

package/src/protocol/handlers/aggregate.ts

@@ -14,19 +14,14 @@ import {
   serializeBatch,
   deserializeBatch,
 } from "../../arrow/index.js";
-import { Protocol } from "@query-farm/vgi-rpc";
+import type { VgiService } from "../../generated/vgi-service.js";
 import type { FunctionRegistry } from "../../functions/registry.js";
 import { deserializeArguments } from "../serialize.js";
 import { deserializeSchema, serializeSchema, batchToSecretDict } from "../../util/arrow/index.js";
 import { toUint8Array } from "../../util/bytes.js";
 import {
-  AggregateBindParamsSchema,
   AggregateBindResultSchema,
-  AggregateCombineParamsSchema,
-  AggregateDestructorParamsSchema,
-  AggregateFinalizeParamsSchema,
   AggregateFinalizeResultSchema,
-  AggregateUpdateParamsSchema,
 } from "../../generated/vgi-protocol-schemas.js";
 import {
   getExecutionState,
@@ -38,14 +33,10 @@ import {
 } from "../../functions/aggregate.js";
 import { Arguments } from "../../arguments/arguments.js";
 import { validateConstConstraints } from "../../arguments/argument-spec.js";
-import {
-  REQUEST_PARAMS_SCHEMA,
-  RESULT_BINARY_SCHEMA,
-  unwrapRequest,
-  wrapResult,
-} from "./shared.js";
+import { unwrapRequest, wrapResult } from "./shared.js";
 
-export function registerAggregateMethods(protocol: Protocol, registry: FunctionRegistry): void {
+/** The aggregate lifecycle's `vgi.v2` handlers. */
+export function aggregateHandlers(registry: FunctionRegistry): Partial<VgiService> {
   // `schemaPath` scopes resolution to the schema the caller named. Every
   // aggregate RPC carries it (protocol 1.2.0), so an aggregate name declared in
   // two schemas dispatches to the one the request names rather than colliding
@@ -69,218 +60,202 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // ------------------------------------------------------------------------
   // aggregate_bind — allocate execution_id, return output schema
   // ------------------------------------------------------------------------
-  protocol.unary("aggregate_bind", {
-    params: AggregateBindParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName: string = innerParams.function_name;
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const argBytes = toUint8Array(innerParams.arguments);
-      const args = deserializeArguments(argBytes);
-      const inputSchema = innerParams.input_schema
-        ? deserializeSchema(toUint8Array(innerParams.input_schema))
-        : null;
-      // Decode the resolved-secrets batch the extension pre-resolves for
-      // aggregates that declared `requiredSecrets`. Mirrors the table-buffering
-      // handler (batchToSecretDict). The secret VALUES are delivered only here,
-      // at bind time — update/combine/finalize see no secrets by design.
-      const secretsBytes = innerParams.secrets ? toUint8Array(innerParams.secrets) : null;
-      const secretsBatch =
-        secretsBytes && secretsBytes.length > 0 ? deserializeBatch(secretsBytes) : null;
-      const secrets = secretsBatch ? batchToSecretDict(secretsBatch) : {};
-      const bindParams: AggregateBindParams<any> = {
-        args: extractArgMap(cfg, args),
-        arguments: args,
-        inputSchema,
-        settings: {},
-        secrets,
-        argumentNames: innerParams.argument_names
-          ? (Array.isArray(innerParams.argument_names)
-            ? innerParams.argument_names
-            : [...innerParams.argument_names])
-            .map((value: unknown) => value == null ? null : String(value))
-          : null,
-      };
-      const executionId = new Uint8Array(16);
-      crypto.getRandomValues(executionId);
-      setExecutionState(executionId, {
-        states: new Map(),
-        bindArgs: args,
-        bindParams,
-      });
-      // Output schema is a single "result" column. Type comes from the
-      // optional onBind hook (for aggregates whose return type depends on
-      // input — e.g. vgi_generic_sum takes ANY and returns the same type);
-      // otherwise the declared cfg.outputType.
-      const outType = cfg.onBind ? await cfg.onBind(bindParams) : cfg.outputType;
-      const outSchema = makeSchema([field("result", outType, true)]);
-      return wrapResult(
-        { output_schema: serializeSchema(outSchema), execution_id: executionId },
-        AggregateBindResultSchema,
-      );
-    },
-  });
+  const aggregateBind: VgiService["aggregateBind"] = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName: string = innerParams.function_name;
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const argBytes = toUint8Array(innerParams.arguments);
+    const args = deserializeArguments(argBytes);
+    const inputSchema = innerParams.input_schema
+      ? deserializeSchema(toUint8Array(innerParams.input_schema))
+      : null;
+    // Decode the resolved-secrets batch the extension pre-resolves for
+    // aggregates that declared `requiredSecrets`. Mirrors the table-buffering
+    // handler (batchToSecretDict). The secret VALUES are delivered only here,
+    // at bind time — update/combine/finalize see no secrets by design.
+    const secretsBytes = innerParams.secrets ? toUint8Array(innerParams.secrets) : null;
+    const secretsBatch =
+      secretsBytes && secretsBytes.length > 0 ? deserializeBatch(secretsBytes) : null;
+    const secrets = secretsBatch ? batchToSecretDict(secretsBatch) : {};
+    const bindParams: AggregateBindParams<any> = {
+      args: extractArgMap(cfg, args),
+      arguments: args,
+      inputSchema,
+      settings: {},
+      secrets,
+      argumentNames: innerParams.argument_names
+        ? (Array.isArray(innerParams.argument_names)
+          ? innerParams.argument_names
+          : [...innerParams.argument_names])
+          .map((value: unknown) => value == null ? null : String(value))
+        : null,
+    };
+    const executionId = new Uint8Array(16);
+    crypto.getRandomValues(executionId);
+    setExecutionState(executionId, {
+      states: new Map(),
+      bindArgs: args,
+      bindParams,
+    });
+    // Output schema is a single "result" column. Type comes from the
+    // optional onBind hook (for aggregates whose return type depends on
+    // input — e.g. vgi_generic_sum takes ANY and returns the same type);
+    // otherwise the declared cfg.outputType.
+    const outType = cfg.onBind ? await cfg.onBind(bindParams) : cfg.outputType;
+    const outSchema = makeSchema([field("result", outType, true)]);
+    return wrapResult(
+      { output_schema: serializeSchema(outSchema), execution_id: executionId },
+      AggregateBindResultSchema,
+    );
+  };
 
   // ------------------------------------------------------------------------
   // aggregate_update — fold the incoming batch into per-group state
   // ------------------------------------------------------------------------
-  protocol.unary("aggregate_update", {
-    params: AggregateUpdateParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName: string = innerParams.function_name;
-      const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
-      if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
+  const aggregateUpdate: VgiService["aggregateUpdate"] = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName: string = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
+    if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
-      const gidIdx = batch.schema.fields.findIndex((f) => f.name === GROUP_COLUMN_NAME);
-      if (gidIdx < 0) {
-        throw new Error(`aggregate_update: input batch missing ${GROUP_COLUMN_NAME} column`);
-      }
-      const gidCol = batch.getChildAt(gidIdx)!;
-      const groupIds: bigint[] = [];
-      const uniqueGids = new Set<bigint>();
-      for (let i = 0; i < batch.numRows; i++) {
-        const v = gidCol.get(i);
-        const g = typeof v === "bigint" ? v : BigInt(v as any);
-        groupIds.push(g);
-        uniqueGids.add(g);
-      }
-      const exec = getExecutionState(executionId, uniqueGids);
-      if (!exec) {
-        throw new Error(`aggregate_update: unknown execution_id for '${functionName}' (bind missing or state dropped)`);
-      }
+    const gidIdx = batch.schema.fields.findIndex((f) => f.name === GROUP_COLUMN_NAME);
+    if (gidIdx < 0) {
+      throw new Error(`aggregate_update: input batch missing ${GROUP_COLUMN_NAME} column`);
+    }
+    const gidCol = batch.getChildAt(gidIdx)!;
+    const groupIds: bigint[] = [];
+    const uniqueGids = new Set<bigint>();
+    for (let i = 0; i < batch.numRows; i++) {
+      const v = gidCol.get(i);
+      const g = typeof v === "bigint" ? v : BigInt(v as any);
+      groupIds.push(g);
+      uniqueGids.add(g);
+    }
+    const exec = getExecutionState(executionId, uniqueGids);
+    if (!exec) {
+      throw new Error(`aggregate_update: unknown execution_id for '${functionName}' (bind missing or state dropped)`);
+    }
 
-      // Build column-arg arrays — every non-__vgi_group_id column, in
-      // schema order — and pass to user's update(). We deliberately do NOT
-      // pre-allocate state for every group_id seen — the user decides when
-      // to call ensureState() so that groups with only-NULL input (skipped
-      // rows) never get an entry, which lets finalize() return SQL NULL.
-      const columns: any[] = [];
-      for (let i = 0; i < batch.schema.fields.length; i++) {
-        if (i === gidIdx) continue;
-        columns.push(batch.getChildAt(i));
+    // Build column-arg arrays — every non-__vgi_group_id column, in
+    // schema order — and pass to user's update(). We deliberately do NOT
+    // pre-allocate state for every group_id seen — the user decides when
+    // to call ensureState() so that groups with only-NULL input (skipped
+    // rows) never get an entry, which lets finalize() return SQL NULL.
+    const columns: any[] = [];
+    for (let i = 0; i < batch.schema.fields.length; i++) {
+      if (i === gidIdx) continue;
+      columns.push(batch.getChildAt(i));
+    }
+    const ensureState = (gid: bigint) => {
+      let s = exec.states.get(gid);
+      if (s === undefined) {
+        s = cfg.initialState(exec.bindParams);
+        exec.states.set(gid, s);
       }
-      const ensureState = (gid: bigint) => {
-        let s = exec.states.get(gid);
-        if (s === undefined) {
-          s = cfg.initialState(exec.bindParams);
-          exec.states.set(gid, s);
-        }
-        return s;
-      };
-      cfg.update({
-        states: exec.states,
-        groupIds,
-        columns,
-        args: exec.bindParams.args,
-        ensureState,
-      });
-      // Flush mutated states to disk so sibling workers see them. We persist
-      // every group that was referenced this call — some may be unchanged
-      // (skipped by NULL handling), in which case the file simply reflects
-      // the pre-existing initial state; the idempotent rewrite is cheap
-      // relative to the RPC overhead.
-      persistGroupStates(executionId, uniqueGids);
-      return wrapResult({}, makeSchema([]));
-    },
-  });
+      return s;
+    };
+    cfg.update({
+      states: exec.states,
+      groupIds,
+      columns,
+      args: exec.bindParams.args,
+      ensureState,
+    });
+    // Flush mutated states to disk so sibling workers see them. We persist
+    // every group that was referenced this call — some may be unchanged
+    // (skipped by NULL handling), in which case the file simply reflects
+    // the pre-existing initial state; the idempotent rewrite is cheap
+    // relative to the RPC overhead.
+    persistGroupStates(executionId, uniqueGids);
+    return wrapResult({}, makeSchema([]));
+  };
 
   // ------------------------------------------------------------------------
   // aggregate_combine — merge (source_group_id, target_group_id) pairs
   // ------------------------------------------------------------------------
-  protocol.unary("aggregate_combine", {
-    params: AggregateCombineParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName: string = innerParams.function_name;
-      const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
-      if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
+  const aggregateCombine: VgiService["aggregateCombine"] = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName: string = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
+    if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
-      const srcCol = batch.getChild("source_group_id")!;
-      const tgtCol = batch.getChild("target_group_id")!;
-      const referencedGids = new Set<bigint>();
-      const srcIds: bigint[] = [];
-      const tgtIds: bigint[] = [];
-      for (let i = 0; i < batch.numRows; i++) {
-        const src = BigInt(srcCol.get(i) as any);
-        const tgt = BigInt(tgtCol.get(i) as any);
-        srcIds.push(src); tgtIds.push(tgt);
-        referencedGids.add(src); referencedGids.add(tgt);
-      }
-      const exec = getExecutionState(executionId, referencedGids);
-      if (!exec) {
-        throw new Error(
-          `aggregate_combine: unknown execution_id for '${functionName}' ` +
-          `(context missing on disk — bind may have failed or been cleaned up)`,
-        );
-      }
-      const touchedTargets = new Set<bigint>();
-      for (let i = 0; i < batch.numRows; i++) {
-        const src = srcIds[i];
-        const tgt = tgtIds[i];
-        const srcHas = exec.states.has(src);
-        const tgtHas = exec.states.has(tgt);
-        if (!srcHas && !tgtHas) continue;
-        const srcState = srcHas ? exec.states.get(src)! : cfg.initialState(exec.bindParams);
-        const tgtState = tgtHas ? exec.states.get(tgt)! : cfg.initialState(exec.bindParams);
-        exec.states.set(tgt, cfg.combine(srcState, tgtState, exec.bindParams));
-        touchedTargets.add(tgt);
-      }
-      persistGroupStates(executionId, touchedTargets);
-      return wrapResult({}, makeSchema([]));
-    },
-  });
+    const srcCol = batch.getChild("source_group_id")!;
+    const tgtCol = batch.getChild("target_group_id")!;
+    const referencedGids = new Set<bigint>();
+    const srcIds: bigint[] = [];
+    const tgtIds: bigint[] = [];
+    for (let i = 0; i < batch.numRows; i++) {
+      const src = BigInt(srcCol.get(i) as any);
+      const tgt = BigInt(tgtCol.get(i) as any);
+      srcIds.push(src); tgtIds.push(tgt);
+      referencedGids.add(src); referencedGids.add(tgt);
+    }
+    const exec = getExecutionState(executionId, referencedGids);
+    if (!exec) {
+      throw new Error(
+        `aggregate_combine: unknown execution_id for '${functionName}' ` +
+        `(context missing on disk — bind may have failed or been cleaned up)`,
+      );
+    }
+    const touchedTargets = new Set<bigint>();
+    for (let i = 0; i < batch.numRows; i++) {
+      const src = srcIds[i];
+      const tgt = tgtIds[i];
+      const srcHas = exec.states.has(src);
+      const tgtHas = exec.states.has(tgt);
+      if (!srcHas && !tgtHas) continue;
+      const srcState = srcHas ? exec.states.get(src)! : cfg.initialState(exec.bindParams);
+      const tgtState = tgtHas ? exec.states.get(tgt)! : cfg.initialState(exec.bindParams);
+      exec.states.set(tgt, cfg.combine(srcState, tgtState, exec.bindParams));
+      touchedTargets.add(tgt);
+    }
+    persistGroupStates(executionId, touchedTargets);
+    return wrapResult({}, makeSchema([]));
+  };
 
   // ------------------------------------------------------------------------
   // aggregate_finalize — emit one result row per requested group_id
   // ------------------------------------------------------------------------
-  protocol.unary("aggregate_finalize", {
-    params: AggregateFinalizeParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName: string = innerParams.function_name;
-      const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
-      const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
-      const groupIds: bigint[] = [];
-      const uniqueGids = new Set<bigint>();
-      if (gidBatch) {
-        const col = gidBatch.getChild("group_id")!;
-        for (let i = 0; i < gidBatch.numRows; i++) {
-          const v = col.get(i);
-          const g = typeof v === "bigint" ? v : BigInt(v as any);
-          groupIds.push(g);
-          uniqueGids.add(g);
-        }
-      }
-      const exec = getExecutionState(executionId, uniqueGids);
-      if (!exec) {
-        throw new Error(`aggregate_finalize: unknown execution_id for '${functionName}'`);
-      }
-      // Groups never updated pass state = null so finalize() can emit SQL NULL
-      // (matches Python semantics for SUM/AVG/MIN/MAX over zero rows).
-      const states = new Map<bigint, any | null>();
-      for (const gid of groupIds) {
-        states.set(gid, exec.states.has(gid) ? exec.states.get(gid) : null);
+  const aggregateFinalize: VgiService["aggregateFinalize"] = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName: string = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
+    const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
+    const groupIds: bigint[] = [];
+    const uniqueGids = new Set<bigint>();
+    if (gidBatch) {
+      const col = gidBatch.getChild("group_id")!;
+      for (let i = 0; i < gidBatch.numRows; i++) {
+        const v = col.get(i);
+        const g = typeof v === "bigint" ? v : BigInt(v as any);
+        groupIds.push(g);
+        uniqueGids.add(g);
       }
-      const resultBatch = cfg.finalize({
-        groupIds, states, outputSchema, args: exec.bindParams.args,
-      });
-      return wrapResult(
-        { result_batch: serializeBatchWithSchema(resultBatch) },
-        AggregateFinalizeResultSchema,
-      );
-    },
-  });
+    }
+    const exec = getExecutionState(executionId, uniqueGids);
+    if (!exec) {
+      throw new Error(`aggregate_finalize: unknown execution_id for '${functionName}'`);
+    }
+    // Groups never updated pass state = null so finalize() can emit SQL NULL
+    // (matches Python semantics for SUM/AVG/MIN/MAX over zero rows).
+    const states = new Map<bigint, any | null>();
+    for (const gid of groupIds) {
+      states.set(gid, exec.states.has(gid) ? exec.states.get(gid) : null);
+    }
+    const resultBatch = cfg.finalize({
+      groupIds, states, outputSchema, args: exec.bindParams.args,
+    });
+    return wrapResult(
+      { result_batch: serializeBatchWithSchema(resultBatch) },
+      AggregateFinalizeResultSchema,
+    );
+  };
 
   // ------------------------------------------------------------------------
   // aggregate_destructor — drop state for finished groups (best-effort)
@@ -291,30 +266,28 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // (matches Python's conservative behavior; the execution entry is cleaned
   // up when the worker process exits).
   // ------------------------------------------------------------------------
-  protocol.unary("aggregate_destructor", {
-    params: AggregateDestructorParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const executionId = toUint8Array(innerParams.execution_id);
-      const exec = getExecutionState(executionId);
-      if (!exec) return wrapResult({}, makeSchema([]));
-      const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
-      if (!gidBatch || gidBatch.numRows === 0) return wrapResult({}, makeSchema([]));
-      const col = gidBatch.getChild("group_id")!;
-      const toDrop = new Set<bigint>();
-      for (let i = 0; i < gidBatch.numRows; i++) {
-        const v = col.get(i);
-        const g = typeof v === "bigint" ? v : BigInt(v as any);
-        exec.states.delete(g);
-        toDrop.add(g);
-      }
-      // Persist deletions (unlinks the per-group file so sibling workers
-      // don't revive the state via getExecutionState's lazy disk load).
-      persistGroupStates(executionId, toDrop);
-      return wrapResult({}, makeSchema([]));
-    },
-  });
+  const aggregateDestructor: VgiService["aggregateDestructor"] = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const executionId = toUint8Array(innerParams.execution_id);
+    const exec = getExecutionState(executionId);
+    if (!exec) return wrapResult({}, makeSchema([]));
+    const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
+    if (!gidBatch || gidBatch.numRows === 0) return wrapResult({}, makeSchema([]));
+    const col = gidBatch.getChild("group_id")!;
+    const toDrop = new Set<bigint>();
+    for (let i = 0; i < gidBatch.numRows; i++) {
+      const v = col.get(i);
+      const g = typeof v === "bigint" ? v : BigInt(v as any);
+      exec.states.delete(g);
+      toDrop.add(g);
+    }
+    // Persist deletions (unlinks the per-group file so sibling workers
+    // don't revive the state via getExecutionState's lazy disk load).
+    persistGroupStates(executionId, toDrop);
+    return wrapResult({}, makeSchema([]));
+  };
+
+  return { aggregateBind, aggregateUpdate, aggregateCombine, aggregateFinalize, aggregateDestructor };
 }
 
 function extractArgMap(