pi-cursor-sdk 0.1.47 → 0.1.48

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.1.48 - 2026-06-22
+
+### Fixed
+
+- Bundle Cursor's Node ConnectRPC transport seam with `undici` `7.28.0` so downstream `pi install npm:pi-cursor-sdk` production installs inherit the audited transport dependency instead of npm's root-only `overrides` fix.
+
 ## 0.1.47 - 2026-06-22
 
 ### Changed

package/README.md

@@ -54,7 +54,7 @@ If pi started without a key, run `/cursor-refresh-models` after `/login` to refr
 - pi 0.79.10 or newer recommended; pi core peer metadata is intentionally unpinned so newer pi releases are not blocked
 - a Cursor SDK API key saved through `/login`, available as `CURSOR_API_KEY`, or passed with pi's `--api-key`
 
-No global `@cursor/sdk` install is required. This package depends on exact `@cursor/sdk@1.0.19`, so normal package installation brings in the SDK version this extension was built and tested against. It also declares `@connectrpc/connect-node@1.7.0` directly because Cursor SDK 1.0.19 still dynamically loads the Node ConnectRPC transport during local-agent runs. Cursor SDK 1.0.19 removes the older `sqlite3 -> node-gyp@8` dependency chain, so deprecated install warnings for `inflight`, `rimraf`, `glob@7`, `npmlog`, `gauge`, `are-we-there-yet`, and `tar@6` from that chain are no longer expected. This package follows pi package guidance by declaring pi core package peers with `"*"` ranges, so users who update pi before this extension is republished are not blocked by peer metadata. The current recommended and validated pi baseline is 0.79.10 plus Cursor SDK 1.0.19; older pi compatibility paths are best-effort and older Cursor SDK compatibility paths are not maintained.
+No global `@cursor/sdk` install is required. This package depends on exact `@cursor/sdk@1.0.19`, so normal package installation brings in the SDK version this extension was built and tested against. It also declares and bundles `@connectrpc/connect-node@1.7.0` with `undici@7.28.0` because Cursor SDK 1.0.19 still dynamically loads the Node ConnectRPC transport during local-agent runs, and npm dependency consumers do not inherit this package's root-only `overrides`. Cursor SDK 1.0.19 removes the older `sqlite3 -> node-gyp@8` dependency chain, so deprecated install warnings for `inflight`, `rimraf`, `glob@7`, `npmlog`, `gauge`, `are-we-there-yet`, and `tar@6` from that chain are no longer expected. This package follows pi package guidance by declaring pi core package peers with `"*"` ranges, so users who update pi before this extension is republished are not blocked by peer metadata. The current recommended and validated pi baseline is 0.79.10 plus Cursor SDK 1.0.19; older pi compatibility paths are best-effort and older Cursor SDK compatibility paths are not maintained.
 
 ## Install
 

package/node_modules/@connectrpc/connect-node/README.md

@@ -0,0 +1,141 @@
+# @connectrpc/connect-node
+
+Connect is a family of libraries for building and consuming APIs on different languages and platforms, and
+[@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) brings type-safe APIs with Protobuf to
+TypeScript.
+
+`@connectrpc/connect-node` provides the following adapters for Node.js:
+
+### createConnectTransport()
+
+Lets your clients running on Node.js talk to a server with the Connect protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createConnectTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the Connect protocol with Node.js `http` module
++ const transport = createConnectTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "1.1"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### createGrpcTransport()
+
+Lets your clients running on Node.js talk to a server with the gRPC protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createGrpcTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the gRPC protocol with Node.js `http2` module
++ const transport = createGrpcTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "2"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### createGrpcWebTransport()
+
+Lets your clients running on Node.js talk to a server with the gRPC-web protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createGrpcWebTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the Connect protocol with Node.js `http` module
++ const transport = createGrpcWebTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "1.1"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### connectNodeAdapter()
+
+Run your Connect RPCs on the Node.js `http`, `https`, or `http2` modules.
+
+```ts
+// connect.ts
+import { ConnectRouter } from "@connectrpc/connect";
+
+export default function (router: ConnectRouter) {
+  // implement rpc Say(SayRequest) returns (SayResponse)
+  router.rpc(ElizaService, ElizaService.methods.say, async (req) => ({
+    sentence: `you said: ${req.sentence}`,
+  }));
+}
+```
+
+```diff
+// server.ts
+import * as http2 from "http2";
++ import routes from "connect";
++ import { connectNodeAdapter } from "@connectrpc/connect-node";
+
+http2.createServer(
++ connectNodeAdapter({ routes }) // responds with 404 for other requests
+).listen(8080);
+```
+
+With that server running, you can make requests with any gRPC, gRPC-Web, or Connect client.
+
+`buf curl` with the gRPC protocol:
+
+```bash
+buf curl --schema buf.build/connectrpc/eliza \
+  --protocol grpc --http2-prior-knowledge \
+  -d '{"sentence": "I feel happy."}' \
+  http://localhost:8080/connectrpc.eliza.v1.ElizaService/Say
+```
+
+`curl` with the Connect protocol:
+
+```bash
+curl \
+    --header "Content-Type: application/json" \
+    --data '{"sentence": "I feel happy."}' \
+     --http2-prior-knowledge \
+    http://localhost:8080/connectrpc.eliza.v1.ElizaService/Say
+```
+
+Node.js with the gRPC protocol:
+
+```ts
+import { createClient } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
+const transport = createGrpcTransport({
+  baseUrl: "http://localhost:8080",
+  httpVersion: "2",
+});
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence); // you said: I feel happy.
+```
+
+A client for the web browser actually looks identical to this example - it would
+simply use `createConnectTransport` from [@connectrpc/connect-web](https://www.npmjs.com/package/@connectrpc/connect-web)
+instead.
+
+## Getting started
+
+To get started with Connect, head over to the [docs](https://connectrpc.com/docs/node/getting-started)
+for a tutorial, or take a look at [our example](https://github.com/connectrpc/connect-es/tree/main/packages/example).

package/node_modules/@connectrpc/connect-node/dist/cjs/compression.d.ts

@@ -0,0 +1,15 @@
+import type { Compression } from "@connectrpc/connect/protocol";
+/**
+ * The gzip compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+export declare const compressionGzip: Compression;
+/**
+ * The brotli compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+export declare const compressionBrotli: Compression;

package/node_modules/@connectrpc/connect-node/dist/cjs/compression.js

@@ -0,0 +1,89 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressionBrotli = exports.compressionGzip = void 0;
+const zlib = require("zlib");
+const util_1 = require("util");
+const connect_1 = require("@connectrpc/connect");
+const node_error_js_1 = require("./node-error.js");
+const gzip = (0, util_1.promisify)(zlib.gzip);
+const gunzip = (0, util_1.promisify)(zlib.gunzip);
+const brotliCompress = (0, util_1.promisify)(zlib.brotliCompress);
+const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
+/**
+ * The gzip compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+exports.compressionGzip = {
+    name: "gzip",
+    compress(bytes) {
+        return gzip(bytes, {});
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return wrapZLibErrors(gunzip(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes);
+    },
+};
+/**
+ * The brotli compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+exports.compressionBrotli = {
+    name: "br",
+    compress(bytes) {
+        return brotliCompress(bytes, {});
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return wrapZLibErrors(brotliDecompress(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes);
+    },
+};
+function wrapZLibErrors(promise, readMaxBytes) {
+    return promise.catch((e) => {
+        const props = (0, node_error_js_1.getNodeErrorProps)(e);
+        let code = connect_1.Code.Internal;
+        let message = "decompression failed";
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (props.code) {
+            case "ERR_BUFFER_TOO_LARGE":
+                code = connect_1.Code.ResourceExhausted;
+                message = `message is larger than configured readMaxBytes ${readMaxBytes} after decompression`;
+                break;
+            case "Z_DATA_ERROR":
+            case "ERR_PADDING_2":
+                code = connect_1.Code.InvalidArgument;
+                break;
+            default:
+                if (props.code !== undefined &&
+                    props.code.startsWith("ERR__ERROR_FORMAT_")) {
+                    code = connect_1.Code.InvalidArgument;
+                }
+                break;
+        }
+        return Promise.reject(new connect_1.ConnectError(message, code, undefined, undefined, e));
+    });
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-node-adapter.d.ts

@@ -0,0 +1,42 @@
+import type { ConnectRouter, ConnectRouterOptions, ContextValues } from "@connectrpc/connect";
+import type { NodeHandlerFn, NodeServerRequest } from "./node-universal-handler.js";
+export interface ConnectNodeAdapterOptions extends ConnectRouterOptions {
+    /**
+     * Route definitions. We recommend the following pattern:
+     *
+     * Create a file `connect.ts` with a default export such as this:
+     *
+     * ```ts
+     * import {ConnectRouter} from "@connectrpc/connect";
+     *
+     * export default (router: ConnectRouter) => {
+     *   router.service(ElizaService, {});
+     * }
+     * ```
+     *
+     * Then pass this function here.
+     */
+    routes: (router: ConnectRouter) => void;
+    /**
+     * If none of the handler request paths match, a 404 is served. This option
+     * can provide a custom fallback for this case.
+     */
+    fallback?: NodeHandlerFn;
+    /**
+     * Serve all handlers under this prefix. For example, the prefix "/something"
+     * will serve the RPC foo.FooService/Bar under "/something/foo.FooService/Bar".
+     * Note that many gRPC client implementations do not allow for prefixes.
+     */
+    requestPathPrefix?: string;
+    /**
+     * Context values to extract from the request. These values are passed to
+     * the handlers.
+     */
+    contextValues?: (req: NodeServerRequest) => ContextValues;
+}
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+export declare function connectNodeAdapter(options: ConnectNodeAdapterOptions): NodeHandlerFn;

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-node-adapter.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectNodeAdapter = connectNodeAdapter;
+const connect_1 = require("@connectrpc/connect");
+const protocol_1 = require("@connectrpc/connect/protocol");
+const node_universal_handler_js_1 = require("./node-universal-handler.js");
+const compression_js_1 = require("./compression.js");
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+function connectNodeAdapter(options) {
+    var _a;
+    if (options.acceptCompression === undefined) {
+        options.acceptCompression = [compression_js_1.compressionGzip, compression_js_1.compressionBrotli];
+    }
+    const router = (0, connect_1.createConnectRouter)(options);
+    options.routes(router);
+    const prefix = (_a = options.requestPathPrefix) !== null && _a !== void 0 ? _a : "";
+    const paths = new Map();
+    for (const uHandler of router.handlers) {
+        paths.set(prefix + uHandler.requestPath, uHandler);
+    }
+    return function nodeRequestHandler(req, res) {
+        var _a, _b, _c, _d;
+        // Strip the query parameter when matching paths.
+        const uHandler = paths.get((_b = (_a = req.url) === null || _a === void 0 ? void 0 : _a.split("?", 2)[0]) !== null && _b !== void 0 ? _b : "");
+        if (!uHandler) {
+            ((_c = options.fallback) !== null && _c !== void 0 ? _c : fallback)(req, res);
+            return;
+        }
+        const uReq = (0, node_universal_handler_js_1.universalRequestFromNodeRequest)(req, res, undefined, (_d = options.contextValues) === null || _d === void 0 ? void 0 : _d.call(options, req));
+        uHandler(uReq)
+            .then((uRes) => (0, node_universal_handler_js_1.universalResponseToNodeResponse)(uRes, res))
+            .catch((reason) => {
+            if (connect_1.ConnectError.from(reason).code == connect_1.Code.Aborted) {
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.error(`handler for rpc ${uHandler.method.name} of ${uHandler.service.typeName} failed`, reason);
+        });
+    };
+}
+const fallback = (request, response) => {
+    response.writeHead(protocol_1.uResponseNotFound.status);
+    response.end();
+};

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-transport.d.ts

@@ -0,0 +1,100 @@
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { Interceptor, Transport } from "@connectrpc/connect";
+import type { Compression } from "@connectrpc/connect/protocol";
+import type { NodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Options used to configure the Connect transport.
+ *
+ * See createConnectTransport().
+ */
+export type ConnectTransportOptions = NodeTransportOptions & {
+    /**
+     * Base URI for all HTTP requests.
+     *
+     * Requests will be made to <baseUrl>/<package>.<service>/method
+     *
+     * Example: `baseUrl: "https://example.com/my-api"`
+     *
+     * This will make a `POST /my-api/my_package.MyService/Foo` to
+     * `example.com` via HTTPS.
+     */
+    baseUrl: string;
+    /**
+     * By default, connect-node clients use the binary format.
+     */
+    useBinaryFormat?: boolean;
+    /**
+     * Interceptors that should be applied to all calls running through
+     * this transport. See the Interceptor type for details.
+     */
+    interceptors?: Interceptor[];
+    /**
+     * Options for the JSON format.
+     * By default, unknown fields are ignored.
+     */
+    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
+    /**
+     * Options for the binary wire format.
+     */
+    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
+    /**
+     * Compression algorithms available to a client. Clients ask servers to
+     * compress responses using any of the registered algorithms. The first
+     * registered algorithm is the most preferred.
+     *
+     * It is safe to use this option liberally: servers will ignore any
+     * compression algorithms they don't support. To compress requests, pair this
+     * option with `sendCompression`.
+     *
+     * If this option is not provided, the compression algorithms "gzip" and "br"
+     * (Brotli) are accepted. To opt out of response compression, pass an
+     * empty array.
+     */
+    acceptCompression?: Compression[];
+    /**
+     * Configures the client to use the specified algorithm to compress request
+     * messages.
+     *
+     * Because some servers don't support compression, clients default to sending
+     * uncompressed requests.
+     */
+    sendCompression?: Compression;
+    /**
+     * Sets a minimum size threshold for compression: Messages that are smaller
+     * than the configured minimum are sent uncompressed.
+     *
+     * The default value is 1 kibibyte, because the CPU cost of compressing very
+     * small messages usually isn't worth the small reduction in network I/O.
+     */
+    compressMinBytes?: number;
+    /**
+     * Limits the performance impact of pathologically large messages sent by the
+     * server. Limits apply to each individual message, not to the stream as a
+     * whole.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    readMaxBytes?: number;
+    /**
+     * Prevents sending messages too large for the server to handle.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    writeMaxBytes?: number;
+    /**
+     * Controls whether or not Connect GET requests should be used when
+     * available, on side-effect free methods. Defaults to false.
+     */
+    useHttpGet?: boolean;
+    /**
+     * The timeout in milliseconds to apply to all requests.
+     *
+     * This can be overridden on a per-request basis by passing a timeoutMs.
+     */
+    defaultTimeoutMs?: number;
+};
+/**
+ * Create a Transport for the Connect protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+export declare function createConnectTransport(options: ConnectTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-transport.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectTransport = createConnectTransport;
+const protocol_connect_1 = require("@connectrpc/connect/protocol-connect");
+const node_transport_options_js_1 = require("./node-transport-options.js");
+/**
+ * Create a Transport for the Connect protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+function createConnectTransport(options) {
+    return (0, protocol_connect_1.createTransport)((0, node_transport_options_js_1.validateNodeTransportOptions)(options));
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/grpc-transport.d.ts

@@ -0,0 +1,96 @@
+import type { Interceptor, Transport } from "@connectrpc/connect";
+import type { Compression } from "@connectrpc/connect/protocol";
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { NodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Options used to configure the gRPC-web transport.
+ *
+ * See createGrpcTransport().
+ */
+export type GrpcTransportOptions = NodeTransportOptions & {
+    /**
+     * Base URI for all HTTP requests.
+     *
+     * Requests will be made to <baseUrl>/<package>.<service>/method
+     *
+     * Example: `baseUrl: "https://example.com/my-api"`
+     *
+     * This will make a `POST /my-api/my_package.MyService/Foo` to
+     * `example.com` via HTTPS.
+     */
+    baseUrl: string;
+    /**
+     * By default, clients use the binary format for gRPC-web, because
+     * not all gRPC-web implementations support JSON.
+     */
+    useBinaryFormat?: boolean;
+    /**
+     * Interceptors that should be applied to all calls running through
+     * this transport. See the Interceptor type for details.
+     */
+    interceptors?: Interceptor[];
+    /**
+     * Options for the JSON format.
+     * By default, unknown fields are ignored.
+     */
+    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
+    /**
+     * Options for the binary wire format.
+     */
+    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
+    /**
+     * Compression algorithms available to a client. Clients ask servers to
+     * compress responses using any of the registered algorithms. The first
+     * registered algorithm is the most preferred.
+     *
+     * It is safe to use this option liberally: servers will ignore any
+     * compression algorithms they don't support. To compress requests, pair this
+     * option with `sendCompression`.
+     *
+     * If this option is not provided, the compression algorithms "gzip" and "br"
+     * (Brotli) are accepted. To opt out of response compression, pass an
+     * empty array.
+     */
+    acceptCompression?: Compression[];
+    /**
+     * Configures the client to use the specified algorithm to compress request
+     * messages.
+     *
+     * Because some servers don't support compression, clients default to sending
+     * uncompressed requests.
+     */
+    sendCompression?: Compression;
+    /**
+     * Sets a minimum size threshold for compression: Messages that are smaller
+     * than the configured minimum are sent uncompressed.
+     *
+     * The default value is 1 kibibyte, because the CPU cost of compressing very
+     * small messages usually isn't worth the small reduction in network I/O.
+     */
+    compressMinBytes?: number;
+    /**
+     * Limits the performance impact of pathologically large messages sent by the
+     * server. Limits apply to each individual message, not to the stream as a
+     * whole.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    readMaxBytes?: number;
+    /**
+     * Prevents sending messages too large for the server to handle.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    writeMaxBytes?: number;
+    /**
+     * The timeout in milliseconds to apply to all requests.
+     *
+     * This can be overridden on a per-request basis by passing a timeoutMs.
+     */
+    defaultTimeoutMs?: number;
+};
+/**
+ * Create a Transport for the gRPC protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+export declare function createGrpcTransport(options: GrpcTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/cjs/grpc-transport.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGrpcTransport = createGrpcTransport;
+const protocol_grpc_1 = require("@connectrpc/connect/protocol-grpc");
+const node_transport_options_js_1 = require("./node-transport-options.js");
+/**
+ * Create a Transport for the gRPC protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+function createGrpcTransport(options) {
+    return (0, protocol_grpc_1.createTransport)((0, node_transport_options_js_1.validateNodeTransportOptions)(options));
+}