pi-cursor-sdk 0.1.49 → 0.1.51

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-overflow.ts

@@ -0,0 +1,96 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage } from "@earendil-works/pi-ai/compat";
+import { CURSOR_PROVIDER } from "./cursor-model.js";
+
+/**
+ * Pi recognizes `context_length_exceeded` (its `OVERFLOW_PATTERNS` includes
+ * `/context[_ ]length[_ ]exceeded/i`) as a context-overflow signal and, on
+ * detecting it, drops the failed assistant message, compacts, and retries once.
+ *
+ * The Cursor provider sanitizes SDK failures into auth/network/generic messages
+ * that pi does NOT treat as overflow, so a genuine Cursor context-overflow
+ * failure would otherwise surface as a plain provider error and bypass pi's
+ * auto-compact-retry recovery. This handler rewrites only Cursor context-window
+ * failures into the `context_length_exceeded` form pi recognizes.
+ *
+ * See pi `docs/custom-provider.md` -> "Context Overflow Errors".
+ */
+export const CURSOR_OVERFLOW_MARKER = "context_length_exceeded";
+
+/**
+ * Context-overflow phrases. These overlap pi's own `OVERFLOW_PATTERNS` so the
+ * false-positive surface matches pi's built-in detection for other providers.
+ *
+ * ponytail: intentionally narrow and textual. We do NOT match bare gRPC
+ * `resource_exhausted` (code 8) or `too many tokens` because pi documents those
+ * can false-match throttling/quota errors and trigger an unwanted compaction.
+ * If a live Cursor probe reveals a distinct overflow phrase, add it here; this
+ * pattern set is the single place to extend without touching the handler.
+ */
+const CURSOR_OVERFLOW_PATTERNS = [
+	/context[_ ]?length/i,
+	/context[_ ]?window/i,
+	/maximum context/i,
+	/prompt is too long/i,
+	/too large for model/i,
+	/exceed(?:s|ed).{0,30}context/i,
+] as const;
+
+/** Never treat rate-limit/throttle signals as overflow (pi retries those separately). */
+const CURSOR_THROTTLE_PATTERN = /too many requests|rate.?limit|throttl|retry.?after/i;
+
+/**
+ * Map a finalized Cursor assistant `errorMessage` to pi's overflow form.
+ * Returns `undefined` when the message is not a Cursor context-overflow failure.
+ *
+ * Pure and idempotent so it is safe to call repeatedly and unit-test in isolation.
+ */
+export function normalizeCursorOverflowErrorMessage(errorMessage: string | undefined): string | undefined {
+	const message = errorMessage?.trim();
+	if (!message) return undefined;
+	// Idempotent: never double-prefix an already-normalized message.
+	if (message.includes(CURSOR_OVERFLOW_MARKER)) return undefined;
+	if (CURSOR_THROTTLE_PATTERN.test(message)) return undefined;
+	if (CURSOR_OVERFLOW_PATTERNS.some((pattern) => pattern.test(message))) {
+		return `${CURSOR_OVERFLOW_MARKER}: ${message}`;
+	}
+	return undefined;
+}
+
+/**
+ * Rewrite a finalized assistant message into pi's overflow form when it is a
+ * Cursor context-overflow failure. Returns the replacement message (for the
+ * `message_end` result) or `undefined` to leave it unchanged.
+ *
+ * `isCursorProvider` carries the provider scoping decision out of the handler so
+ * the full logic is unit-testable without a pi event harness.
+ */
+export function rewriteCursorOverflowAssistantMessage(
+	message: AssistantMessage,
+	isCursorProvider: boolean,
+): AssistantMessage | undefined {
+	if (!isCursorProvider || message.stopReason !== "error") return undefined;
+	const rewritten = normalizeCursorOverflowErrorMessage(message.errorMessage);
+	if (!rewritten) return undefined;
+	return { ...message, errorMessage: rewritten };
+}
+
+export type CursorOverflowExtensionApi = Pick<ExtensionAPI, "on">;
+
+/**
+ * Register a `message_end` handler that rewrites Cursor context-overflow
+ * failures into the `context_length_exceeded` form pi auto-compacts on.
+ *
+ * Guarded exactly as pi's provider docs require: scoped to the Cursor provider,
+ * only for `stopReason === "error"`, never for throttling, and idempotent.
+ */
+export function registerCursorOverflowNormalization(pi: CursorOverflowExtensionApi): void {
+	pi.on("message_end", (event, ctx) => {
+		const message = event.message;
+		if (message.role !== "assistant") return undefined;
+		const isCursorProvider = message.provider === CURSOR_PROVIDER || ctx.model?.provider === CURSOR_PROVIDER;
+		const rewritten = rewriteCursorOverflowAssistantMessage(message, isCursorProvider);
+		if (!rewritten) return undefined;
+		return { message: rewritten };
+	});
+}

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/src/index.ts

@@ -11,6 +11,7 @@ import { streamCursorLazy } from "./cursor-provider-lazy.js";
 import { CURSOR_API_KEY_CONFIG_VALUE } from "./cursor-api-key.js";
 import { registerCursorFallbackIssueWarning } from "./cursor-fallback-warning.js";
 import { registerCursorAgentsContextDedup } from "./cursor-agents-context-registration.js";
+import { registerCursorOverflowNormalization } from "./cursor-provider-overflow.js";
 
 type CursorExtensionApi =
 	& Pick<ExtensionAPI, "registerProvider" | "registerCommand" | "on">
@@ -22,7 +23,8 @@ type CursorExtensionApi =
 	& Parameters<typeof registerCursorSkillTool>[0]
 	& Parameters<typeof registerCursorPiToolBridge>[0]
 	& Parameters<typeof registerCursorFallbackIssueWarning>[0]
-	& Parameters<typeof registerCursorAgentsContextDedup>[0];
+	& Parameters<typeof registerCursorAgentsContextDedup>[0]
+	& Parameters<typeof registerCursorOverflowNormalization>[0];
 
 function createCursorProviderConfig(models: ProviderModelConfig[]): ProviderConfig {
 	return {
@@ -53,6 +55,7 @@ export default async function (pi: CursorExtensionApi) {
 	registerCursorSkillTool(pi);
 	registerCursorPiToolBridge(pi);
 	registerCursorAgentsContextDedup(pi);
+	registerCursorOverflowNormalization(pi);
 	let fallbackIssue: CursorModelFallbackIssue | undefined;
 	const models = await discoverModels({
 		onFallback: (issue) => {

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));
-}