pi-cursor-sdk 0.1.47 → 0.1.48

package/node_modules/@connectrpc/connect-node/dist/cjs/grpc-web-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 createGrpcWebTransport().
+ */
+export type GrpcWebTransportOptions = 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-web protocol using the Node.js `http`,
+ * `http2`, or `http2` module.
+ */
+export declare function createGrpcWebTransport(options: GrpcWebTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/cjs/grpc-web-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.createGrpcWebTransport = createGrpcWebTransport;
+const protocol_grpc_web_1 = require("@connectrpc/connect/protocol-grpc-web");
+const node_transport_options_js_1 = require("./node-transport-options.js");
+/**
+ * Create a Transport for the gRPC-web protocol using the Node.js `http`,
+ * `http2`, or `http2` module.
+ */
+function createGrpcWebTransport(options) {
+    return (0, protocol_grpc_web_1.createTransport)((0, node_transport_options_js_1.validateNodeTransportOptions)(options));
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/http2-session-manager.d.ts

@@ -0,0 +1,146 @@
+import * as http2 from "http2";
+export interface Http2SessionOptions {
+    /**
+     * The interval to send PING frames to keep a connection alive. The interval
+     * is reset whenever a stream receives data. If a PING frame is not responded
+     * to within pingTimeoutMs, the connection and all open streams close.
+     *
+     * By default, no PING frames are sent. If a value is provided, PING frames
+     * are sent only for connections that have open streams, unless
+     * pingIdleConnections is enabled.
+     *
+     * Sensible values can be between 10 seconds and 2 hours, depending on your
+     * infrastructure.
+     *
+     * This option is equivalent to GRPC_ARG_KEEPALIVE_TIME_MS in gRPC Core.
+     */
+    pingIntervalMs?: number;
+    /**
+     * Enable PING frames for connections that are have no open streams.
+     * This option is only effective if a value for pingIntervalMs is provided.
+     *
+     * Note that it may not be necessary to enable this option. If a request is
+     * made on a connection that has not been used for longer than pingIntervalMs,
+     * a PING frame is sent to verify that the connection is still alive, and a
+     * new connection is opened transparently if necessary.
+     *
+     * Defaults to false.
+     *
+     * This option is equivalent to GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS in
+     * gRPC Core.
+     */
+    pingIdleConnection?: boolean;
+    /**
+     * Timeout for PING frames. If a PING is not answered within this time, the
+     * connection is considered dead.
+     *
+     * Defaults to 15 seconds. This option is only used if a value for
+     * pingIntervalMs is provided.
+     *
+     * This option is equivalent to GRPC_ARG_KEEPALIVE_TIMEOUT_MS in gRPC Core.
+     */
+    pingTimeoutMs?: number;
+    /**
+     * Automatically close a connection if the time since the last request stream
+     * exceeds this value.
+     *
+     * Defaults to 15 minutes.
+     *
+     * This option is equivalent to GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS of gRPC core.
+     */
+    idleConnectionTimeoutMs?: number;
+}
+/**
+ * Manage an HTTP/2 connection and keep it alive with PING frames.
+ *
+ * The logic is based on "Basic Keepalive" described in
+ * https://github.com/grpc/proposal/blob/0ba0c1905050525f9b0aee46f3f23c8e1e515489/A8-client-side-keepalive.md#basic-keepalive
+ * as well as the client channel arguments described in
+ * https://github.com/grpc/grpc/blob/8e137e524a1b1da7bbf4603662876d5719563b57/doc/keepalive.md
+ *
+ * Usually, the managers tracks exactly one connection, but if a connection
+ * receives a GOAWAY frame with NO_ERROR, the connection is maintained until
+ * all streams have finished, and new requests will open a new connection.
+ */
+export declare class Http2SessionManager {
+    /**
+     * The host this session manager connect to.
+     */
+    authority: string;
+    /**
+     * The current state of the connection:
+     *
+     * - "closed"
+     *   The connection is closed, or no connection has been opened yet.
+     * - connecting
+     *   Currently establishing a connection.
+     *
+     * - "open"
+     *   A connection is open and has open streams. PING frames are sent every
+     *   pingIntervalMs, unless a stream received data.
+     *   If a PING frame is not responded to within pingTimeoutMs, the connection
+     *   and all open streams close.
+     *
+     * - "idle"
+     *   A connection is open, but it does not have any open streams.
+     *   If pingIdleConnection is enabled, PING frames are used to keep the
+     *   connection alive, similar to an "open" connection.
+     *   If a connection is idle for longer than idleConnectionTimeoutMs, it closes.
+     *   If a request is made on an idle connection that has not been used for
+     *   longer than pingIntervalMs, the connection is verified.
+     *
+     * - "verifying"
+     *   Verifying a connection after a long period of inactivity before issuing a
+     *   request. A PING frame is sent, and if it times out within pingTimeoutMs, a
+     *   new connection is opened.
+     *
+     * - "error"
+     *   The connection is closed because of a transient error. A connection
+     *   may have failed to reach the host, or the connection may have died,
+     *   or it may have been aborted.
+     */
+    state(): "closed" | "connecting" | "open" | "idle" | "verifying" | "error";
+    /**
+     * Returns the error object if the connection is in the "error" state,
+     * `undefined` otherwise.
+     */
+    error(): unknown;
+    private s;
+    private shuttingDown;
+    private readonly http2SessionOptions;
+    private readonly options;
+    private verifying;
+    constructor(url: URL | string, pingOptions?: Http2SessionOptions, http2SessionOptions?: http2.ClientSessionOptions | http2.SecureClientSessionOptions);
+    /**
+     * Open a connection if none exists, verify an existing connection if
+     * necessary.
+     */
+    connect(): Promise<"open" | "idle" | "error">;
+    /**
+     * Issue a request.
+     *
+     * This method automatically opens a connection if none exists, and verifies
+     * an existing connection if necessary. It calls http2.ClientHttp2Session.request(),
+     * and keeps track of all open http2.ClientHttp2Stream.
+     *
+     * Clients must call notifyResponseByteRead() whenever they successfully read
+     * data from the http2.ClientHttp2Stream.
+     */
+    request(method: string, path: string, headers: http2.OutgoingHttpHeaders, options: Omit<http2.ClientSessionRequestOptions, "signal">): Promise<http2.ClientHttp2Stream>;
+    /**
+     * Notify the manager of a successful read from a http2.ClientHttp2Stream.
+     *
+     * Clients must call this function whenever they successfully read data from
+     * a http2.ClientHttp2Stream obtained from request(). This informs the
+     * keep-alive logic that the connection is alive, and prevents it from sending
+     * unnecessary PING frames.
+     */
+    notifyResponseByteRead(stream: http2.ClientHttp2Stream): void;
+    /**
+     * If there is an open connection, close it. This also closes any open streams.
+     */
+    abort(reason?: Error): void;
+    private gotoReady;
+    private setState;
+    private verify;
+}