pi-cursor-sdk 0.1.50 → 0.1.52

package/src/cursor-provider-errors.ts

@@ -73,6 +73,19 @@ function collectConnectErrorEvidence(error: unknown, record: Record<string, unkn
 	return evidence.join("\n");
 }
 
+function collectConnectErrorStacks(error: unknown, record: Record<string, unknown> | undefined): string {
+	const stacks: string[] = [];
+	let value = error;
+	let currentRecord = record;
+	for (let depth = 0; depth < 3 && currentRecord; depth += 1) {
+		const stack = getErrorStack(value, currentRecord).trim();
+		if (stack) stacks.push(stack);
+		value = currentRecord.cause;
+		currentRecord = asRecord(value);
+	}
+	return stacks.join("\n");
+}
+
 function isConnectError(error: unknown, record: Record<string, unknown> | undefined): boolean {
 	const name = error instanceof Error ? error.name : getErrorStringField(record, "name");
 	return name === "ConnectError";
@@ -86,6 +99,17 @@ function isUnavailableConnectCode(code: unknown): boolean {
 	return code === 14 || (typeof code === "string" && /^(?:14|unavailable)$/i.test(code));
 }
 
+function isCursorSdkStallAbortNetworkError(code: unknown, evidence: string, stackEvidence: string): boolean {
+	return (
+		(code === 2 || (typeof code === "string" && /^(?:2|unknown)$/i.test(code))) &&
+		/(?:operation was aborted|canceled)/i.test(evidence) &&
+		/(?:AbortError|operation was aborted)/i.test(`${evidence}\n${stackEvidence}`) &&
+		stackEvidence.includes("@cursor/sdk") &&
+		stackEvidence.includes("@connectrpc/connect-node") &&
+		/\b(?:onStall|reportStall|StallDetected)\b/i.test(stackEvidence)
+	);
+}
+
 function isCursorExtensionConnectStack(stack: string): boolean {
 	// pi runs Cursor SDK in Node, where the SDK dynamically imports connect-node.
 	// connect-web is the SDK's Bun/Deno path and is intentionally not classified for supported pi runs.
@@ -128,6 +152,7 @@ export function classifyCursorConnectError(error: unknown): CursorConnectErrorCl
 	const causeName = getErrorStringField(cause, "name");
 	const stack = getErrorStack(error, record);
 	const evidence = collectConnectErrorEvidence(error, record);
+	const stackEvidence = collectConnectErrorStacks(error, record);
 
 	if (
 		(code === 1 || code === "canceled") &&
@@ -139,6 +164,10 @@ export function classifyCursorConnectError(error: unknown): CursorConnectErrorCl
 		return { kind: "abort", source: "cursor-sdk-stack" };
 	}
 
+	if (isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence)) {
+		return { kind: "network", source: getCursorConnectSource(error, record) };
+	}
+
 	if (isUnauthenticatedConnectCode(code) || isLikelyAuthError(evidence)) {
 		return { kind: "unauthenticated", source: getCursorConnectSource(error, record) };
 	}

package/src/cursor-provider-turn-runner.ts

@@ -46,7 +46,6 @@ export class CursorProviderTurnRunner {
 		});
 
 		try {
-			stream.push({ type: "start", partial });
 			this.throwIfAborted();
 			const cwd = getCursorSessionCwd();
 			this.sdkEventDebug = CursorSdkEventDebugSink.maybeCreate({
@@ -62,6 +61,7 @@ export class CursorProviderTurnRunner {
 			) {
 				return;
 			}
+			this.throwIfAborted();
 
 			this.resolvedApiKey = requireCursorApiKey(options);
 			prepared = await prepareCursorProviderTurn({

package/src/cursor-provider.ts

@@ -22,6 +22,8 @@ import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-gu
 import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { CursorProviderTurnRunner } from "./cursor-provider-turn-runner.js";
+import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { runExclusiveCursorSessionTurn, __testUtils as cursorSessionTurnQueueTestUtils } from "./cursor-session-turn-queue.js";
 
 function makeInitialMessage(model: Model<Api>): AssistantMessage {
 	return {
@@ -54,7 +56,6 @@ export function streamCursor(
 
 	(async () => {
 		const partial = makeInitialMessage(model);
-		const sdkProcessErrorGuard = installCursorSdkProcessErrorGuard();
 
 		const runner = new CursorProviderTurnRunner({
 			model,
@@ -66,7 +67,12 @@ export function streamCursor(
 		});
 
 		try {
-			await runner.run(sdkProcessErrorGuard);
+			stream.push({ type: "start", partial });
+			await runExclusiveCursorSessionTurn(
+				getCursorSessionScopeKey(),
+				() => runner.run(installCursorSdkProcessErrorGuard()),
+				options?.signal,
+			);
 		} catch (error) {
 			await runner.handleOuterCatch(error);
 		}
@@ -93,4 +99,5 @@ export const __testUtils = {
 	resetCursorNativeReplayIdleDisposeMs,
 	releaseAllPendingCursorLiveRunsForTests,
 	resetSessionCursorAgents: () => disposeAllSessionCursorAgents(),
+	resetSessionTurnQueue: cursorSessionTurnQueueTestUtils.reset,
 };

package/src/cursor-session-turn-queue.ts

@@ -0,0 +1,52 @@
+import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
+
+const turnQueuesByScope = new Map<string, Promise<void>>();
+
+async function waitForPreviousTurn(previous: Promise<void>, signal?: AbortSignal): Promise<void> {
+	if (!signal) {
+		await previous.catch(() => undefined);
+		return;
+	}
+	if (signal.aborted) throw new CursorLiveRunAbortError();
+	await new Promise<void>((resolve, reject) => {
+		const onAbort = (): void => {
+			reject(new CursorLiveRunAbortError());
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		previous.catch(() => undefined).then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		});
+	});
+}
+
+export async function runExclusiveCursorSessionTurn<T>(scopeKey: string, body: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+	const previous = turnQueuesByScope.get(scopeKey);
+	let releaseCurrent!: () => void;
+	const current = new Promise<void>((resolve) => {
+		releaseCurrent = resolve;
+	});
+	const tail = (previous ?? Promise.resolve()).catch(() => undefined).then(() => current);
+	turnQueuesByScope.set(scopeKey, tail);
+	void tail.finally(() => {
+		if (turnQueuesByScope.get(scopeKey) === tail) {
+			turnQueuesByScope.delete(scopeKey);
+		}
+	});
+
+	try {
+		if (previous) await waitForPreviousTurn(previous, signal);
+		return await body();
+	} finally {
+		releaseCurrent();
+	}
+}
+
+export const __testUtils = {
+	reset(): void {
+		turnQueuesByScope.clear();
+	},
+	count(): number {
+		return turnQueuesByScope.size;
+	},
+};

package/src/cursor-tool-manifest.ts

@@ -4,7 +4,7 @@ import type { CursorPiToolBridgeSnapshot } from "./cursor-pi-tool-bridge-types.j
 export const CURSOR_TOOL_MANIFEST_ENV = "PI_CURSOR_TOOL_MANIFEST";
 
 /**
- * Representative @cursor/sdk@1.0.19 local-agent ToolType values; actual exposure can vary by run.
+ * Representative @cursor/sdk@1.0.22 local-agent ToolType values; actual exposure can vary by run.
  * See docs/cursor-native-tool-replay.md#sdk-tooltype-replay-matrix.
  */
 export const CURSOR_HOST_TOOL_MANIFEST_SUMMARY =

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

@@ -1,141 +0,0 @@
-# @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

@@ -1,15 +0,0 @@
-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

@@ -1,89 +0,0 @@
-"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

@@ -1,42 +0,0 @@
-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

@@ -1,61 +0,0 @@
-"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

@@ -1,100 +0,0 @@
-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

@@ -1,25 +0,0 @@
-"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));
-}