@query-farm/vgi 0.28.0 → 0.29.1

package/src/http/fetch.ts

@@ -10,10 +10,23 @@
 // `buildVgiProtocol` as `signingKey`, from one source. Passing different keys to
 // those two seams produces a worker that mints tokens it cannot recover.
 
-import { createHttpHandler, unpackStateToken, type Protocol } from "@query-farm/vgi-rpc";
+import {
+  AuthContext,
+  createHttpHandler,
+  unpackStateToken,
+  type AuthenticateFn,
+  type DispatchHook,
+  type DispatchInfo,
+  type HookToken,
+  type PeerAuthenticationPolicy,
+  type PeerIdentityProvider,
+  type PeerResolutionOptions,
+  type Protocol,
+} from "@query-farm/vgi-rpc";
 import { arrowStateSerializer } from "../protocol/state-serializer.js";
 import { buildVgiProtocol, type ProtocolConfig } from "../protocol/dispatch.js";
 import { createLandingRoutes, type LandingInfo } from "./landing.js";
+import { setRequestAuthScope, type RequestAuthHolder } from "../request-auth.js";
 
 export interface VgiFetchOptions {
   /** Wire-protocol config (registry + catalogInterface). */
@@ -57,8 +70,106 @@ export interface VgiFetchOptions {
    *  its required name/doc/version; the CF entry had to remember, and
    *  vgi-open-meteo shipped for weeks without it. */
   landingInfo: LandingInfo;
+  /** Authenticates each incoming request, returning the caller's
+   *  {@link AuthContext}. Forwarded verbatim to `createHttpHandler`; omit it
+   *  and every caller is anonymous, which is what this package did before the
+   *  option existed.
+   *
+   *  Supplying it is what makes a worker able to serve more than one principal,
+   *  and the identity it returns is the one the worker seals `attach_opaque_data`
+   *  and split tokens under. */
+  authenticate?: AuthenticateFn;
+  /** Off-wire transport identities, including a trusted Iroh HTTP bridge. */
+  peerIdentityProviders?: readonly PeerIdentityProvider[];
+  /** Policy composing peer evidence with application authentication. */
+  peerAuthenticationPolicy?: PeerAuthenticationPolicy;
+  /** Host adapter supplying the physical peer and multiplicity-preserving headers. */
+  peerResolutionContext?: (request: Request) => PeerResolutionOptions | Promise<PeerResolutionOptions>;
+}
+
+// ---------------------------------------------------------------------------
+// Request-scoped caller identity
+//
+// `@query-farm/vgi-rpc` types stream initialization as `(params) => state` —
+// no CallContext — on both dispatchers, so the `init` handler cannot be handed
+// the principal as an argument the way every unary handler is. But `init` is
+// exactly where the identity-bound envelopes minted by `catalog_attach` and
+// `table_function_plan` (both unary, both sealed under the REAL caller) are
+// opened. Opening them under the anonymous identity works for anonymous
+// callers and fails for everyone else.
+//
+// So the identity travels the way vgi-python's `current_auth()` ContextVar
+// does: an ambient per-request scope. `AsyncLocalStorage.run` wraps the whole
+// handler call, and a dispatch hook fills the holder in with whatever identity
+// the framework actually dispatched under — the hook is read AFTER
+// authentication, the PKCE cookie chain and bearer introspection have all had
+// their say, so it reports the final principal rather than re-deriving one.
+//
+// A mutable holder rather than `enterWith`: `run` is the only form Cloudflare
+// Workers supports, and the identity is not known until authentication has run
+// inside the handler.
+// ---------------------------------------------------------------------------
+
+/** The `AsyncLocalStorage` surface used here, structurally typed so this file
+ *  compiles where `node:async_hooks` has no types. */
+interface AsyncLocalStorageLike<T> {
+  run<R>(store: T, fn: () => R): R;
+  getStore(): T | undefined;
 }
 
+let requestAuthStorage: AsyncLocalStorageLike<RequestAuthHolder> | null | undefined;
+let requestAuthStoragePending: Promise<AsyncLocalStorageLike<RequestAuthHolder> | null> | undefined;
+
+/**
+ * Resolve (once) the AsyncLocalStorage this process scopes requests with.
+ *
+ * `node:async_hooks` is loaded dynamically and defensively: it exists on Node
+ * and Bun, and on Cloudflare Workers only with the `nodejs_compat` /
+ * `nodejs_als` compatibility flag. Where it is missing this resolves to `null`
+ * and the worker keeps serving exactly as it did before — anonymous callers
+ * unaffected, authenticated ones still unable to open their sealed attach.
+ * Degrading is the right failure here: refusing to start would break every
+ * anonymous deployment to fix a case it does not have.
+ */
+function ensureRequestAuthStorage(): Promise<AsyncLocalStorageLike<RequestAuthHolder> | null> {
+  if (requestAuthStorage !== undefined) return Promise.resolve(requestAuthStorage);
+  requestAuthStoragePending ??= import("node:async_hooks")
+    .then((mod) => {
+      const storage = new mod.AsyncLocalStorage<RequestAuthHolder>() as AsyncLocalStorageLike<RequestAuthHolder>;
+      requestAuthStorage = storage;
+      setRequestAuthScope(storage);
+      return storage;
+    })
+    .catch(() => {
+      requestAuthStorage = null;
+      return null;
+    });
+  return requestAuthStoragePending;
+}
+
+/**
+ * Dispatch hook that records the dispatching principal on the open scope.
+ *
+ * Reads the identity off `DispatchInfo`, which the framework populates from the
+ * resolved auth context for every method — so this sees the same principal the
+ * access log and the unary handlers see, without this package having to know
+ * how authentication was configured.
+ */
+const REQUEST_AUTH_DISPATCH_HOOK: DispatchHook = {
+  onDispatchStart(info: DispatchInfo): HookToken {
+    const holder = requestAuthStorage?.getStore();
+    if (holder) {
+      holder.auth = info.authenticated
+        ? new AuthContext(info.authDomain ?? "", true, info.principal ?? "", info.claims ?? {})
+        : AuthContext.anonymous();
+    }
+    return undefined;
+  },
+  onDispatchEnd() {
+    // Nothing to record; the scope ends when the request does.
+  },
+};
+
 /**
  * Build a fetch handler suitable for `export default { fetch }` in a CF
  * Worker module, or for `Bun.serve({ fetch })`. The returned handler is
@@ -100,6 +211,14 @@ export function createVgiFetch(opts: VgiFetchOptions): (req: Request) => Promise
     tokenKey: opts.signingKey,
     tokenTtl,
     stateSerializer: arrowStateSerializer,
+    // Records the dispatching principal on the request scope opened below, so
+    // stream `init` — the one handler the framework passes no CallContext to —
+    // can still open the identity-bound attach and split envelopes.
+    dispatchHook: REQUEST_AUTH_DISPATCH_HOOK,
+    authenticate: opts.authenticate,
+    peerIdentityProviders: opts.peerIdentityProviders,
+    peerAuthenticationPolicy: opts.peerAuthenticationPolicy,
+    peerResolutionContext: opts.peerResolutionContext,
     // `null` is the explicit opt-out; `undefined` (omitted) means "*".
     corsOrigins: opts.corsOrigins === null ? undefined : (opts.corsOrigins ?? "*"),
     repositoryUrl: opts.repositoryUrl,
@@ -110,5 +229,13 @@ export function createVgiFetch(opts: VgiFetchOptions): (req: Request) => Promise
     extraRoutes: createLandingRoutes(opts.landingInfo),
     enableLandingPage: false,
   });
-  return async (req: Request) => handler(req);
+  return async (req: Request) => {
+    const storage = await ensureRequestAuthStorage();
+    // No AsyncLocalStorage on this host: serve exactly as before.
+    if (!storage) return handler(req);
+    // One holder per request. The dispatch hook fills it in once the framework
+    // has resolved the principal; `init` reads it back through
+    // `currentRequestAuth()`.
+    return storage.run({}, () => handler(req));
+  };
 }

package/src/index.core.ts

@@ -77,7 +77,7 @@ export {
 export type { VgiFunction, FunctionMeta, StreamHandlers, FunctionExample, HandlerState } from "./functions/types.js";
 
 // Catalog
-export { CatalogInterface, type CatalogAttachResult, type SchemaInfo, encodeSchemaInfo, decodeSchemaInfo, type TableInfo, encodeTableInfo, decodeTableInfo, type ViewInfo, encodeViewInfo, decodeViewInfo, type CatalogInfo, encodeCatalogInfo, decodeCatalogInfo, type FunctionInfo, encodeFunctionInfo, decodeFunctionInfo, type FunctionInfoOptions, type MacroInfo, encodeMacroInfo, decodeMacroInfo, type MacroType, type CopyFromFormatInfo, encodeCopyFromFormatInfo, type AttachOpaqueData, type TransactionOpaqueData, buildScanBranchesResult, type ScanBranchInput } from "./catalog/interface.js";
+export { CatalogInterface, type CatalogAttachResult, type SchemaInfo, encodeSchemaInfo, decodeSchemaInfo, type TableInfo, encodeTableInfo, decodeTableInfo, type ViewInfo, encodeViewInfo, decodeViewInfo, type CatalogInfo, encodeCatalogInfo, decodeCatalogInfo, type FunctionInfo, encodeFunctionInfo, decodeFunctionInfo, type FunctionInfoOptions, type MacroInfo, encodeMacroInfo, decodeMacroInfo, type MacroType, type CopyFromFormatInfo, encodeCopyFromFormatInfo, type AttachOpaqueData, type TransactionOpaqueData, buildScanBranchesResult, encodeFormatOptions, type ScanBranchInput } from "./catalog/interface.js";
 export type { CatalogDescriptor, SchemaDescriptor, TableDescriptor, ViewDescriptor, MacroDescriptor, SettingDescriptor, SecretTypeDescriptor, ForeignKeyDef, DefaultValue } from "./catalog/descriptors.js";
 export { ReadOnlyCatalogInterface } from "./catalog/read-only.js";
 export { CompositeCatalogInterface } from "./catalog/composite.js";
@@ -88,6 +88,7 @@ export {
   FunctionType,
   FunctionStability,
   NullHandling,
+  ArgumentMonotonicity,
   OrderPreservation,
   OrderDependence,
   DistinctDependence,
@@ -219,7 +220,7 @@ export {
   int8, int16, int64,
   uint8, uint16, uint32, uint64,
   float16, float64,
-  utf8, binary, fixedSizeBinary,
+  utf8, largeUtf8, binary, largeBinary, fixedSizeBinary,
   decimal, decimal128, decimal256,
   date, dateDay, dateMillisecond,
   time, timeSecond, timeMillisecond, timeMicrosecond, timeNanosecond,
@@ -307,3 +308,4 @@ export type {
 export { str, bytes, int, int32, float, float32, bool, toSchema, OutputCollector, AuthContext } from "@query-farm/vgi-rpc";
 export { subprocessConnect, httpConnect, tcpConnect } from "@query-farm/vgi-rpc";
 export type { RpcClient, StreamSession, LogMessage } from "@query-farm/vgi-rpc";
+export { normalizeSchemaPath, schemaPathDisplay, schemaPathKey, schemaPathsEqual, type SchemaPath } from "./schema-path.js";

package/src/metadata/resolve.ts

@@ -4,6 +4,7 @@
 import {
   FunctionStability,
   NullHandling,
+  ArgumentMonotonicity,
   OrderPreservation,
   OrderDependence,
   DistinctDependence,
@@ -11,6 +12,7 @@ import {
 } from "../types.js";
 import type { VgiFunction } from "../functions/types.js";
 import type { ArgumentSpec } from "../arguments/argument-spec.js";
+import { supportsExtensionFilterFunction } from "../filter-pushdown/capabilities.js";
 import {
   CatalogFunctionType,
   type ResolvedMetadata,
@@ -55,6 +57,19 @@ function specToParameterInfo(spec: ArgumentSpec): ParameterInfo {
 export function resolveMetadata(func: VgiFunction): ResolvedMetadata {
   const meta = func.meta;
 
+  if (meta.runtimeFilterAlgorithms?.length) {
+    throw new Error("TypeScript SDK has no registered runtime-filter artifact evaluator to advertise");
+  }
+  if (meta.filterEvaluationContexts?.length) {
+    throw new Error("TypeScript SDK has no isolated DuckDB session-context evaluator to advertise");
+  }
+  if (meta.filterSemanticProfiles?.some((value) => value !== "vgi.duckdb.standard.v1")) {
+    throw new Error("TypeScript SDK supports only vgi.duckdb.standard.v1 filter semantics");
+  }
+  if (meta.additionalFilterFunctions?.some((value) => !supportsExtensionFilterFunction(value))) {
+    throw new Error("TypeScript SDK cannot advertise an extension-filter function without an evaluator");
+  }
+
   let functionType: CatalogFunctionType;
   switch (func.kind) {
     case "scalar":
@@ -74,8 +89,28 @@ export function resolveMetadata(func: VgiFunction): ResolvedMetadata {
       functionType = CatalogFunctionType.TABLE;
   }
 
+  const argumentMonotonicity = meta.argumentMonotonicity ?? null;
+  if (argumentMonotonicity !== null && functionType !== CatalogFunctionType.SCALAR) {
+    throw new Error("argumentMonotonicity is only valid for scalar functions");
+  }
+
   const parameters: ParameterInfo[] = func.argumentSpecs.map(specToParameterInfo);
 
+  if (argumentMonotonicity !== null) {
+    if (argumentMonotonicity.length !== parameters.length) {
+      throw new Error(
+        `argumentMonotonicity has ${argumentMonotonicity.length} entries, ` +
+        `expected ${parameters.length} declaration slots`,
+      );
+    }
+    const allowed = new Set<string>(Object.values(ArgumentMonotonicity));
+    for (const [index, value] of argumentMonotonicity.entries()) {
+      if (!allowed.has(value)) {
+        throw new Error(`argumentMonotonicity[${index}] has unknown value ${String(value)}`);
+      }
+    }
+  }
+
   const examples: FunctionExample[] = (meta.examples ?? []).map((e) => ({
     sql: e.sql,
     description: e.description,
@@ -95,12 +130,19 @@ export function resolveMetadata(func: VgiFunction): ResolvedMetadata {
     parameters,
     stability: meta.stability ?? FunctionStability.CONSISTENT,
     nullHandling: meta.nullHandling ?? NullHandling.DEFAULT,
+    argumentMonotonicity,
     requiredSettings: meta.requiredSettings ?? [],
     requiredSecrets: meta.requiredSecrets ?? [],
     projectionPushdown: meta.projectionPushdown ?? false,
     filterPushdown: meta.filterPushdown ?? false,
     samplingPushdown: meta.samplingPushdown ?? false,
-    supportedExpressionFilters: meta.supportedExpressionFilters ?? [],
+    filterSemanticProfiles: meta.filterSemanticProfiles ?? (meta.filterPushdown ? ["vgi.duckdb.standard.v1"] : []),
+    additionalFilterFunctions: meta.additionalFilterFunctions ?? [],
+    runtimeFilterAlgorithms: meta.runtimeFilterAlgorithms ?? [],
+    filterEvaluationContexts: (meta.filterEvaluationContexts ?? []).map((value) => ({
+      profile: value.profile,
+      providerFingerprint: value.providerFingerprint ?? null,
+    })),
     preservesOrder: meta.preservesOrder ?? OrderPreservation.NO_ORDER_GUARANTEE,
     maxWorkers: maxWorkers === DEFAULT_MAX_WORKERS ? null : maxWorkers,
     orderDependent: meta.orderDependent ?? OrderDependence.NOT_ORDER_DEPENDENT,

package/src/metadata/serialize.ts

@@ -8,6 +8,7 @@ import {
   field,
   utf8,
   int32,
+  uint64,
   bool,
   list,
   struct as makeStruct,
@@ -16,6 +17,7 @@ import {
   emptyBatch,
 } from "../arrow/index.js";
 import type { ResolvedMetadata, ParameterInfo, FunctionExample } from "./types.js";
+import type { ArgumentMonotonicity } from "../types.js";
 
 // ============================================================================
 // Schema definitions matching Python's _METADATA_SCHEMA exactly
@@ -41,6 +43,17 @@ const PARAMETER_STRUCT = makeStruct([
   field("is_const", bool(), false),
 ]);
 
+const FILTER_IDENTITY_STRUCT = makeStruct([
+  field("namespace", utf8(), false),
+  field("name", utf8(), false),
+  field("version", uint64(), false),
+]);
+
+const FILTER_CONTEXT_STRUCT = makeStruct([
+  field("profile", utf8(), false),
+  field("provider_fingerprint", utf8(), true),
+]);
+
 const METADATA_SCHEMA = makeSchema([
   field("name", utf8(), false),
   field("class_name", utf8(), false),
@@ -52,10 +65,15 @@ const METADATA_SCHEMA = makeSchema([
   field("parameters", list(field("item", PARAMETER_STRUCT, true)), false),
   field("stability", utf8(), false),
   field("null_handling", utf8(), false),
+  field("argument_monotonicity", list(field("item", utf8(), true)), true),
   field("required_settings", list(field("item", utf8(), true)), false),
   field("required_secrets", list(field("item", utf8(), true)), false),
   field("projection_pushdown", bool(), false),
   field("filter_pushdown", bool(), false),
+  field("filter_semantic_profiles", list(field("item", utf8(), true)), false),
+  field("additional_filter_functions", list(field("item", FILTER_IDENTITY_STRUCT, true)), false),
+  field("runtime_filter_algorithms", list(field("item", FILTER_IDENTITY_STRUCT, true)), false),
+  field("filter_evaluation_contexts", list(field("item", FILTER_CONTEXT_STRUCT, true)), false),
   field("preserves_order", utf8(), false),
   field("max_workers", int32(), true),
   field("order_dependent", utf8(), false),
@@ -96,12 +114,23 @@ function metadataToRow(m: ResolvedMetadata): Record<string, any> {
     })),
     stability: m.stability,
     null_handling: m.nullHandling,
+    argument_monotonicity: m.argumentMonotonicity,
     required_settings: m.requiredSettings,
     required_secrets: m.requiredSecrets,
     projection_pushdown: m.projectionPushdown,
     filter_pushdown: m.filterPushdown,
     sampling_pushdown: m.samplingPushdown,
-    supported_expression_filters: m.supportedExpressionFilters,
+    filter_semantic_profiles: m.filterSemanticProfiles,
+    additional_filter_functions: m.additionalFilterFunctions.map((value) => ({
+      ...value, version: BigInt(value.version),
+    })),
+    runtime_filter_algorithms: m.runtimeFilterAlgorithms.map((value) => ({
+      ...value, version: BigInt(value.version),
+    })),
+    filter_evaluation_contexts: m.filterEvaluationContexts.map((value) => ({
+      profile: value.profile,
+      provider_fingerprint: value.providerFingerprint,
+    })),
     preserves_order: m.preservesOrder,
     max_workers: m.maxWorkers,
     order_dependent: m.orderDependent,
@@ -222,15 +251,24 @@ export function arrowToMetadatas(batch: VgiBatch): ResolvedMetadata[] {
       parameters,
       stability: (get("stability") as any) ?? "CONSISTENT",
       nullHandling: (get("null_handling") as any) ?? "DEFAULT",
+      argumentMonotonicity: get("argument_monotonicity") == null
+        ? null
+        : [...(get("argument_monotonicity") as any)].map(String) as ArgumentMonotonicity[],
       requiredSettings,
       requiredSecrets,
       projectionPushdown: (get("projection_pushdown") as boolean) ?? false,
       filterPushdown: (get("filter_pushdown") as boolean) ?? false,
       samplingPushdown: (get("sampling_pushdown") as boolean) ?? false,
-      supportedExpressionFilters: (() => {
-        const raw = get("supported_expression_filters") as any ?? [];
-        return raw ? [...raw].filter((s: any) => s != null).map(String) : [];
-      })(),
+      filterSemanticProfiles: [...((get("filter_semantic_profiles") as any) ?? [])].filter((s: any) => s != null).map(String),
+      additionalFilterFunctions: [...((get("additional_filter_functions") as any) ?? [])].filter((v: any) => v != null).map((v: any) => ({
+        namespace: String(v.namespace), name: String(v.name), version: Number(v.version),
+      })),
+      runtimeFilterAlgorithms: [...((get("runtime_filter_algorithms") as any) ?? [])].filter((v: any) => v != null).map((v: any) => ({
+        namespace: String(v.namespace), name: String(v.name), version: Number(v.version),
+      })),
+      filterEvaluationContexts: [...((get("filter_evaluation_contexts") as any) ?? [])].filter((v: any) => v != null).map((v: any) => ({
+        profile: String(v.profile), providerFingerprint: v.provider_fingerprint == null ? null : String(v.provider_fingerprint),
+      })),
       preservesOrder: (get("preserves_order") as any) ?? "NO_ORDER_GUARANTEE",
       maxWorkers: (get("max_workers") as number | null) ?? null,
       orderDependent: (get("order_dependent") as any) ?? "NOT_ORDER_DEPENDENT",

package/src/metadata/types.ts

@@ -4,6 +4,7 @@
 import {
   FunctionStability,
   NullHandling,
+  ArgumentMonotonicity,
   OrderPreservation,
   OrderDependence,
   DistinctDependence,
@@ -36,6 +37,17 @@ export interface FunctionExample {
   expectedOutput: string | null;
 }
 
+export interface FilterFunctionCapability {
+  namespace: string;
+  name: string;
+  version: number;
+}
+
+export interface EvaluationContextCapability {
+  profile: string;
+  providerFingerprint: string | null;
+}
+
 export interface ResolvedMetadata {
   name: string;
   className: string;
@@ -47,12 +59,16 @@ export interface ResolvedMetadata {
   parameters: ParameterInfo[];
   stability: FunctionStability;
   nullHandling: NullHandling;
+  argumentMonotonicity: ArgumentMonotonicity[] | null;
   requiredSettings: string[];
   requiredSecrets: string[];
   projectionPushdown: boolean;
   filterPushdown: boolean;
   samplingPushdown: boolean;
-  supportedExpressionFilters: string[];
+  filterSemanticProfiles: string[];
+  additionalFilterFunctions: FilterFunctionCapability[];
+  runtimeFilterAlgorithms: FilterFunctionCapability[];
+  filterEvaluationContexts: EvaluationContextCapability[];
   preservesOrder: OrderPreservation;
   maxWorkers: number | null;
   orderDependent: OrderDependence;

package/src/protocol/dispatch.ts

@@ -37,7 +37,7 @@ export interface ProtocolConfig {
 }
 
 export function buildVgiProtocol(config: ProtocolConfig): Protocol {
-  const protocol = new Protocol("vgi");
+  const protocol = new Protocol("vgi", { protocolVersion: "2.0.0" });
 
   registerFunctionMethods(protocol, {
     registry: config.registry,

package/src/protocol/handlers/aggregate.ts

@@ -20,8 +20,13 @@ 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,
@@ -41,19 +46,19 @@ import {
 } from "./shared.js";
 
 export function registerAggregateMethods(protocol: Protocol, registry: FunctionRegistry): void {
-  // `schemaName` scopes resolution to the schema the caller named. Every
+  // `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
   // on the flat by-name index. `null` (no schema) keeps the cross-schema lookup.
   function resolveAggregate(
     name: string,
-    schemaName?: string | null,
+    schemaPath?: string[] | null,
   ): AggregateFunctionConfig<any, any> {
     const func = registry.get(name, {
       arguments: new Arguments(),
       inputSchema: null,
       isScalar: false,
-      schemaName: schemaName ?? null,
+      schemaPath: schemaPath ?? null,
     }) as any;
     if (!func || func.kind !== "aggregate") {
       throw new Error(`Function '${name}' is not an aggregate function`);
@@ -65,12 +70,12 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // aggregate_bind — allocate execution_id, return output schema
   // ------------------------------------------------------------------------
   protocol.unary("aggregate_bind", {
-    params: REQUEST_PARAMS_SCHEMA,
+    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_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const argBytes = toUint8Array(innerParams.arguments);
       const args = deserializeArguments(argBytes);
       const inputSchema = innerParams.input_schema
@@ -90,6 +95,12 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
         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);
@@ -115,13 +126,13 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // aggregate_update — fold the incoming batch into per-group state
   // ------------------------------------------------------------------------
   protocol.unary("aggregate_update", {
-    params: REQUEST_PARAMS_SCHEMA,
+    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_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
       if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
@@ -182,13 +193,13 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // aggregate_combine — merge (source_group_id, target_group_id) pairs
   // ------------------------------------------------------------------------
   protocol.unary("aggregate_combine", {
-    params: REQUEST_PARAMS_SCHEMA,
+    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_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
       if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
@@ -231,13 +242,13 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // aggregate_finalize — emit one result row per requested group_id
   // ------------------------------------------------------------------------
   protocol.unary("aggregate_finalize", {
-    params: REQUEST_PARAMS_SCHEMA,
+    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_name ?? null);
+      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[] = [];
@@ -281,7 +292,7 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
   // up when the worker process exits).
   // ------------------------------------------------------------------------
   protocol.unary("aggregate_destructor", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: AggregateDestructorParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: (params) => {
       const innerParams = unwrapRequest(params.request);