@cortexkit/anthropic-auth-core 2.0.2 → 2.1.0

package/dist/request-gzip.d.ts

@@ -0,0 +1,99 @@
+/** Claude Code's own opt-out: `0`/`false` turns gzip off, `1`/`true` forces it. */
+export declare const GZIP_REQUEST_BODIES_ENV = "CLAUDE_CODE_GZIP_REQUEST_BODIES";
+/** How long a persisted latch keeps gzip off. */
+export declare const GZIP_LATCH_TTL_MS: number;
+export type RequestGzipSkipReason = 'version' | 'host' | 'env_off' | 'below_min_size' | 'proxy' | 'mtls' | 'custom_ca' | 'latched_off';
+export type RequestGzipDecision = {
+    gzip: true;
+    forced: boolean;
+} | {
+    gzip: false;
+    reason: RequestGzipSkipReason;
+};
+export type GzipRejectionKind = 'non_anthropic_rejection' | 'invalid_json_at_origin';
+/**
+ * What the caller's transport adds beyond the environment: a proxy, a custom
+ * certificate authority or a client certificate the caller passes to fetch
+ * itself. Claude Code sends uncompressed bodies through any of these.
+ */
+export interface RequestGzipTransport {
+    proxy?: boolean;
+    customCa?: boolean;
+    mtls?: boolean;
+}
+type Env = Record<string, string | undefined>;
+/**
+ * Remembers that a gzipped body was rejected. Any rejection turns gzip off
+ * for this process; a proxy rejection followed by an accepted uncompressed
+ * resend also writes `{latchedAt, status}` to `path`, which keeps gzip off
+ * for seven days in later processes. The file belongs to this plugin, not to
+ * the user's settings. An expired, future-dated or unreadable record is
+ * removed when read.
+ */
+export declare class RequestGzipLatch {
+    #private;
+    readonly path?: string | undefined;
+    readonly now: () => number;
+    constructor(path?: string | undefined, now?: () => number);
+    get latchedThisProcess(): boolean;
+    latchProcess(): void;
+    /** Whether the latch file holds a record younger than seven days (read once). */
+    persistedInEffect(): Promise<boolean>;
+    persist(status: number): Promise<void>;
+}
+/** One latch per storage path, shared by every send path in this process. */
+export declare function getRequestGzipLatch(path?: string): RequestGzipLatch;
+/** The latch file path: `<stem>-request-gzip.json` beside the account storage file. */
+export declare function getRequestGzipLatchPath(accountStoragePath: string): string;
+/** Decide, in Claude Code's order, whether this request body goes out gzipped. */
+export declare function decideRequestGzip(options: {
+    url: string | URL;
+    body: unknown;
+    latch: RequestGzipLatch;
+    env?: Env;
+    transport?: RequestGzipTransport;
+}): Promise<RequestGzipDecision>;
+/** A newline and 0 to 256 random spaces and tabs, as Claude Code appends. */
+export declare function requestGzipPadding(random?: () => number): string;
+/**
+ * The gzipped wire bytes for a signed identity body: `cch` reset to `00000`,
+ * padding appended, one gzip member at level 6. Never sign the result.
+ */
+export declare function encodeGzipRequestBody(identityBody: string, random?: () => number): Promise<Uint8Array>;
+/**
+ * Claude Code's test for a rejected gzipped body: a 400, 403 or 415 that
+ * either did not come from Anthropic (no `req_` request id and no `cf-ray`)
+ * or, for a 400, says the JSON could not be parsed. Any other response,
+ * including an ordinary API 400, is not a gzip problem. Reads at most 8 KiB
+ * from a clone, so the response itself stays unread.
+ */
+export declare function classifyGzipRejection(response: Response): Promise<GzipRejectionKind | null>;
+export interface RequestGzipEvent {
+    decision: RequestGzipDecision;
+    rejection?: {
+        kind: GzipRejectionKind;
+        status: number;
+    };
+    resendStatus?: number;
+    persisted?: boolean;
+}
+/**
+ * Send a signed identity body, gzipped when Claude Code would gzip it.
+ *
+ * `send` performs one physical request with the given body and headers; it is
+ * called once, or twice when the gzipped body is rejected: the second call
+ * gets the identity body and the same headers (same `x-client-request-id`,
+ * same retry count) minus `content-encoding`. That resend is not a retry.
+ */
+export declare function sendWithRequestGzip(options: {
+    url: string | URL;
+    body: string;
+    headers: Headers;
+    send: (body: string | Uint8Array, headers: Headers) => Promise<Response>;
+    latch: RequestGzipLatch;
+    env?: Env;
+    transport?: RequestGzipTransport;
+    random?: () => number;
+    onEvent?: (event: RequestGzipEvent) => void;
+}): Promise<Response>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,12 +30,12 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@cortexkit/common-auth": "0.17.0"
+    "@cortexkit/common-auth": "0.21.1"
   },
   "dependencies": {
-    "@cortexkit/claustrum-client": "0.9.0",
+    "@cortexkit/claustrum-client": "0.12.0",
     "@cortexkit/private-files": "0.2.1",
-    "@cortexkit/subc-client": "^0.16.0",
+    "@cortexkit/subc-client": "^0.22.0",
     "jsonc-parser": "^3.3.1",
     "xxhash-wasm": "^1.1.0"
   }