pi-cursor-sdk 0.1.50 → 0.1.51

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

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

@@ -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.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

@@ -1,146 +0,0 @@
-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;
-}