@openhoo/hoopilot 2.1.5 → 2.1.7

package/dist/codexx.js

@@ -3,7 +3,7 @@ import {
   buildCodexxInvocation,
   main,
   verifyCodexxModel
-} from "./chunk-4ZG5QEYJ.js";
+} from "./chunk-2GLKVNAA.js";
 export {
   buildCodexxInvocation,
   main,

package/dist/index.d.ts

@@ -12,7 +12,7 @@ declare class MetricsRegistry {
         now?: () => number;
     });
     /** Mark a request as started; pair with exactly one {@link observe}. */
-    startRequest(): void;
+    startRequest(route?: string): void;
     /** Record a completed request and clear its in-flight slot. */
     observe(observation: RequestObservation): void;
     /**
@@ -35,24 +35,10 @@ declare class MetricsRegistry {
      */
     recordGithubRateLimit(rateLimit: GithubRateLimit | undefined): void;
     /** A JSON-friendly view of the current counters. */
-    snapshot(now?: () => number): MetricsSnapshot;
+    snapshot(nowOrOptions?: (() => number) | MetricsSnapshotOptions): MetricsSnapshot;
     /** Render the Prometheus text exposition format (version 0.0.4). */
     renderPrometheus(now?: () => number): string;
 }
-/**
- * Wrap `response`'s body so the client receives unchanged bytes while the same
- * read pass extracts token usage. Returns a new Response carrying the observed
- * body and the original status/headers. Usage extraction never throws into the
- * client stream: a parse failure or an aborted client simply yields no usage.
- * When the body is absent the response is returned untouched.
- *
- * Pass the request's `signal` so a client disconnect cancels the observer
- * branch; combined with the runtime cancelling the client branch, that releases
- * the shared upstream connection instead of draining it in the background.
- */
-declare function observeResponseUsage(response: Response, fallbackModel: string, onUsage: (model: string, usage: TokenUsage) => void, signal?: AbortSignal, onOutcome?: (extracted: boolean) => void): Response;
-/** Extract and record token usage from an already-buffered response body. */
-declare function recordResponseTextUsage(text: string, isSse: boolean, fallbackModel: string, onUsage: (model: string, usage: TokenUsage) => void, onOutcome?: (extracted: boolean) => void): void;
 
 type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 interface Logger {
@@ -243,6 +229,12 @@ interface MetricsSnapshot {
     };
     uptimeSeconds: number;
 }
+/** Options for deriving a JSON metrics snapshot without changing raw counters. */
+interface MetricsSnapshotOptions {
+    excludeRoutes?: readonly string[];
+    excludeUpstreamPaths?: readonly string[];
+    now?: () => number;
+}
 /** JSON body returned by the proxy's `/v1/usage` route. */
 interface UsageResponseBody {
     copilot: CopilotUsage | null;
@@ -252,18 +244,6 @@ interface UsageResponseBody {
     version: string;
 }
 
-interface AnthropicStreamOptions {
-    model: string;
-    messageId?: string;
-}
-declare class AnthropicCompatibilityError extends Error {
-    constructor(message: string);
-}
-declare function anthropicMessagesToResponsesRequest(request: JsonObject): JsonObject;
-declare function responsesResponseToAnthropicMessage(response: JsonObject, fallbackModel: string): JsonObject;
-declare function responsesStreamToAnthropicStream(stream: ReadableStream<Uint8Array>, options: AnthropicStreamOptions): ReadableStream<Uint8Array>;
-declare function estimateAnthropicMessageTokens(request: JsonObject): JsonObject;
-
 declare const DEFAULT_COPILOT_API_BASE_URL = "https://api.githubcopilot.com";
 declare class CopilotAuthError extends Error {
     constructor(message: string);
@@ -339,6 +319,9 @@ declare class CopilotClient {
  */
 declare function normalizeCopilotUsage(body: unknown): CopilotUsage;
 
+/** Default model Hoopilot uses when a client does not supply one. */
+declare const DEFAULT_MODEL = "gpt-5.5";
+
 interface GithubCopilotDeviceLoginOptions {
     clientId?: string;
     domain?: string;
@@ -361,44 +344,7 @@ declare function createHoopilotLogger(options?: HoopilotLoggerOptions): Hoopilot
 declare function parseLogFormat(value: string | undefined): LogFormat;
 declare function parseLogLevel(value: string | undefined): LogLevel;
 
-declare const DEFAULT_MODEL = "gpt-4.1";
-interface ResponseStreamOptions {
-    model: string;
-    responseId?: string;
-}
-declare class OpenAICompatibilityError extends Error {
-    constructor(message: string);
-}
-declare function responsesRequestToChatCompletion(request: JsonObject): JsonObject;
-declare function normalizeChatCompletionRequest(request: JsonObject): JsonObject;
-declare function completionsRequestToChatCompletion(request: JsonObject): JsonObject;
-declare function normalizeRequestedModel(model: unknown): string;
-declare function chatCompletionToResponse(completion: JsonObject, responseId?: string): JsonObject;
-/**
- * Reduce a Copilot `/responses` result into the `{ output }` document Codex's
- * remote-compaction client (`POST /responses/compact`) deserializes. Codex keeps
- * only assistant/user message items from `output` and discards everything else,
- * so a Responses `output` array passes through verbatim; when the upstream only
- * exposes `output_text` (or, for a stream it did not honor `stream: false` on,
- * `output_text` deltas) a single assistant message is synthesized instead. The
- * input may be a unary JSON body or an SSE stream, so both framings are handled.
- */
-declare function responsesCompactionResult(upstreamText: string, isSse: boolean): JsonObject;
-declare function chatCompletionToCompletion(completion: JsonObject): JsonObject;
-declare function completionStreamFromChatStream(chatStream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
-declare function normalizeModelsResponse(upstream: unknown): JsonObject;
-declare function fallbackModels(): Array<JsonObject>;
-declare function responsesStreamFromChatStream(chatStream: ReadableStream<Uint8Array>, options: ResponseStreamOptions): ReadableStream<Uint8Array>;
-/**
- * Normalize an upstream `usage` object into {@link TokenUsage}. Accepts both the
- * Chat Completions shape (`prompt_tokens`/`completion_tokens`) and the Responses
- * shape (`input_tokens`/`output_tokens`), and pulls nested reasoning/cached
- * details when present. Returns undefined when no token counts are available so
- * callers can distinguish "no usage reported" from "zero tokens".
- */
-declare function extractTokenUsage(usage: unknown): TokenUsage | undefined;
-
 declare function createHoopilotHandler(options?: HoopilotServerOptions): (request: Request) => Promise<Response>;
 declare function startHoopilotServer(options?: HoopilotServerOptions): StartedHoopilotServer;
 
-export { AnthropicCompatibilityError, COPILOT_USAGE_API_VERSION, type CopilotAccess, CopilotAuth, CopilotAuthError, type CopilotAuthOptions, CopilotClient, type CopilotQuota, type CopilotUsage, DEFAULT_COPILOT_API_BASE_URL, DEFAULT_GITHUB_API_BASE_URL, DEFAULT_LOG_FORMAT, DEFAULT_LOG_LEVEL, DEFAULT_MODEL, type FetchLike, type GithubRateLimit, type GithubRateLimitSnapshot, type HoopilotLogger, type HoopilotLoggerOptions, type HoopilotServerOptions, type JsonObject, type LatencySnapshot, type LogFields, type LogFormat, type LogLevel, type LogMethod, type Logger, MetricsRegistry, type MetricsSnapshot, type ModelTokenTotals, OpenAICompatibilityError, PROMETHEUS_CONTENT_TYPE, type RequestObservation, type RouteLatency, type StartedHoopilotServer, type StreamingProxyMode, type TokenUsage, type UsageResponseBody, anthropicMessagesToResponsesRequest, applyCopilotHeaders, applyGithubApiHeaders, authStorePath, chatCompletionToCompletion, chatCompletionToResponse, completionStreamFromChatStream, completionsRequestToChatCompletion, createHoopilotHandler, createHoopilotLogger, estimateAnthropicMessageTokens, extractTokenUsage, fallbackModels, githubCopilotDeviceLogin, noopLogger, normalizeChatCompletionRequest, normalizeCopilotUsage, normalizeModelsResponse, normalizeRequestedModel, observeResponseUsage, parseLogFormat, parseLogLevel, parseRateLimitHeaders, readStoredCopilotAuth, recordResponseTextUsage, responsesCompactionResult, responsesRequestToChatCompletion, responsesResponseToAnthropicMessage, responsesStreamFromChatStream, responsesStreamToAnthropicStream, startHoopilotServer, writeStoredCopilotAuth };
+export { COPILOT_USAGE_API_VERSION, type CopilotAccess, CopilotAuth, CopilotAuthError, type CopilotAuthOptions, CopilotClient, type CopilotQuota, type CopilotUsage, DEFAULT_COPILOT_API_BASE_URL, DEFAULT_GITHUB_API_BASE_URL, DEFAULT_LOG_FORMAT, DEFAULT_LOG_LEVEL, DEFAULT_MODEL, type FetchLike, type GithubRateLimit, type GithubRateLimitSnapshot, type HoopilotLogger, type HoopilotLoggerOptions, type HoopilotServerOptions, type JsonObject, type LatencySnapshot, type LogFields, type LogFormat, type LogLevel, type LogMethod, type Logger, MetricsRegistry, type MetricsSnapshot, type ModelTokenTotals, PROMETHEUS_CONTENT_TYPE, type RequestObservation, type RouteLatency, type StartedHoopilotServer, type StreamingProxyMode, type TokenUsage, type UsageResponseBody, applyCopilotHeaders, applyGithubApiHeaders, authStorePath, createHoopilotHandler, createHoopilotLogger, githubCopilotDeviceLogin, noopLogger, normalizeCopilotUsage, parseLogFormat, parseLogLevel, parseRateLimitHeaders, readStoredCopilotAuth, startHoopilotServer, writeStoredCopilotAuth };