@openhoo/hoopilot 0.5.4 → 0.5.6

package/README.md

@@ -101,37 +101,42 @@ Use with Codex CLI after Hoopilot is running:
 
 ```powershell
 $env:OPENAI_API_KEY = "local-key"
-codex -m gpt-5.5 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
+codex -m gpt-4.1 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
 ```
 
 One-line PowerShell form:
 
 ```powershell
-$env:OPENAI_API_KEY = "local-key"; codex -m gpt-5.5 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
+$env:OPENAI_API_KEY = "local-key"; codex -m gpt-4.1 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
 ```
 
 Or use the bundled `codexx` convenience command after Hoopilot is already running:
 
 ```powershell
 $env:HOOPILOT_API_KEY = "local-key"
-codexx -m gpt-5.5
+codexx -m gpt-4.1
 ```
 
 Without a global install, run it through npm:
 
 ```powershell
 $env:HOOPILOT_API_KEY = "local-key"
-npx --package @openhoo/hoopilot codexx -m gpt-5.5
+npx --package @openhoo/hoopilot codexx -m gpt-4.1
 ```
 
-`codexx` does not start Hoopilot and does not change your shell environment. It only
-runs `codex` with `openai_base_url` pointed at `http://127.0.0.1:4141/v1`, maps
-`HOOPILOT_API_KEY` to `OPENAI_API_KEY` for that child process, passes
+`codexx` does not start Hoopilot and does not change your shell environment. It runs
+`codex` with a temporary `hoopilot` model provider pointed at
+`http://127.0.0.1:4141/v1`, disables Codex Responses WebSockets for that provider,
+maps `HOOPILOT_API_KEY` to `OPENAI_API_KEY` for that child process, passes
 `--disable network_proxy` to Codex, and removes standard proxy variables from the
 spawned Codex process so Codex talks directly to the local server. Override the local
 URL with `CODEXX_BASE_URL`, the local key with `CODEXX_API_KEY`, or the Codex
 executable with `CODEXX_CODEX_BIN`.
 
+Copilot only accepts model IDs supported by your Copilot account. Hoopilot defaults
+to `gpt-4.1`, aliases Codex-only `gpt-5.5` requests to `gpt-4.1`, and retries one
+clear Copilot "model not supported" error with `gpt-4.1`.
+
 If no `HOOPILOT_API_KEY` is configured, Hoopilot accepts local requests without client authentication. Binding to a non-loopback host requires `HOOPILOT_API_KEY` unless `--allow-unauthenticated` is set.
 
 ## Logging
@@ -193,7 +198,7 @@ Then, in another PowerShell session:
 $env:OPENAI_API_KEY = "local-key"
 Invoke-RestMethod -Headers @{ Authorization = "Bearer $env:OPENAI_API_KEY" } `
   http://127.0.0.1:4141/v1/models
-codex -m gpt-5.5 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
+codex -m gpt-4.1 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
 ```
 
 If that returns `401 copilot_auth_error`, rerun `npx @openhoo/hoopilot login` and confirm the GitHub account has active Copilot access.

package/dist/cli.js

@@ -339,16 +339,6 @@ var CopilotClient = class {
       signal
     });
   }
-  async forwardChatCompletions(body, signal) {
-    return this.fetchCopilot("/chat/completions", {
-      body,
-      headers: {
-        "content-type": "application/json"
-      },
-      method: "POST",
-      signal
-    });
-  }
   async models(signal) {
     return this.fetchCopilot("/models", {
       headers: {
@@ -378,6 +368,10 @@ var CopilotClient = class {
 
 // src/openai.ts
 var DEFAULT_MODEL = "gpt-4.1";
+var MODEL_ALIASES = {
+  "gpt-5.5": DEFAULT_MODEL,
+  "gpt-5.5-codex": DEFAULT_MODEL
+};
 function responsesRequestToChatCompletion(request) {
   const messages = [];
   const instructions = contentToText(request.instructions);
@@ -392,7 +386,7 @@ function responsesRequestToChatCompletion(request) {
     max_tokens: request.max_output_tokens ?? request.max_tokens,
     messages,
     metadata: request.metadata,
-    model: contentToText(request.model) || DEFAULT_MODEL,
+    model: normalizeRequestedModel(request.model),
     presence_penalty: request.presence_penalty,
     reasoning_effort: asRecord(request.reasoning).effort,
     response_format: asRecord(request.text).format,
@@ -404,16 +398,29 @@ function responsesRequestToChatCompletion(request) {
     top_p: request.top_p
   });
 }
+function normalizeChatCompletionRequest(request) {
+  return removeUndefined({
+    ...request,
+    model: normalizeRequestedModel(request.model)
+  });
+}
 function completionsRequestToChatCompletion(request) {
   return removeUndefined({
     max_tokens: request.max_tokens,
     messages: [{ content: promptToText(request.prompt), role: "user" }],
-    model: contentToText(request.model) || DEFAULT_MODEL,
+    model: normalizeRequestedModel(request.model),
     stream: request.stream === true,
     temperature: request.temperature,
     top_p: request.top_p
   });
 }
+function normalizeRequestedModel(model) {
+  const requested = contentToText(model).trim();
+  if (!requested) {
+    return DEFAULT_MODEL;
+  }
+  return MODEL_ALIASES[requested.toLowerCase()] ?? requested;
+}
 function chatCompletionToResponse(completion, responseId) {
   const id = responseId ?? `resp_${randomId()}`;
   const choice = firstChoice(completion);
@@ -946,6 +953,13 @@ function createHoopilotHandler(options = {}) {
           { logger: requestLogger, requestId, startedAt }
         );
       }
+      if (request.method === "GET" && apiPath === "/v1/responses") {
+        return finishResponse(websocketUnsupportedResponse(), {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        });
+      }
       if (request.method === "GET" && apiPath === "/v1/models") {
         return finishResponse(await handleModels(client, request.signal, requestLogger), {
           logger: requestLogger,
@@ -1055,7 +1069,9 @@ async function handleModels(client, signal, logger) {
   return jsonResponse(normalizeModelsResponse(await upstream.json()));
 }
 async function handleChatCompletions(client, request, logger) {
-  const upstream = await client.forwardChatCompletions(await request.text(), request.signal);
+  const chatRequest = normalizeChatCompletionRequest(await readJson(request));
+  const result = await sendChatCompletions(client, chatRequest, request.signal, logger);
+  const upstream = result.upstream;
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
@@ -1064,10 +1080,13 @@ async function handleChatCompletions(client, request, logger) {
 }
 async function handleCompletions(client, request, logger) {
   const body = await readJson(request);
-  const upstream = await client.chatCompletions(
+  const result = await sendChatCompletions(
+    client,
     completionsRequestToChatCompletion(body),
-    request.signal
+    request.signal,
+    logger
   );
+  const upstream = result.upstream;
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
@@ -1077,7 +1096,8 @@ async function handleCompletions(client, request, logger) {
 async function handleResponses(client, request, logger) {
   const body = await readJson(request);
   const chatRequest = responsesRequestToChatCompletion(body);
-  const upstream = await client.chatCompletions(chatRequest, request.signal);
+  const result = await sendChatCompletions(client, chatRequest, request.signal, logger);
+  const upstream = result.upstream;
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
@@ -1085,7 +1105,7 @@ async function handleResponses(client, request, logger) {
   if (body.stream === true && upstream.body) {
     return new Response(
       responsesStreamFromChatStream(upstream.body, {
-        model: typeof chatRequest.model === "string" ? chatRequest.model : "gpt-4.1"
+        model: result.model
       }),
       {
         headers: {
@@ -1099,6 +1119,52 @@ async function handleResponses(client, request, logger) {
   }
   return jsonResponse(chatCompletionToResponse(await upstream.json()));
 }
+async function sendChatCompletions(client, chatRequest, signal, logger) {
+  const model = requestModel(chatRequest);
+  const upstream = await client.chatCompletions(chatRequest, signal);
+  if (upstream.ok || isUpstreamAuthStatus(upstream.status)) {
+    return { model, upstream };
+  }
+  const text = await upstream.text();
+  if (!shouldRetryWithDefaultModel(upstream.status, text, model)) {
+    return { model, upstream: textResponse(upstream, text) };
+  }
+  logger.warn(
+    {
+      event: "copilot.model.fallback",
+      fallbackModel: DEFAULT_MODEL,
+      upstreamPath: "/chat/completions",
+      upstreamStatus: upstream.status
+    },
+    "retrying chat completion with fallback model"
+  );
+  return {
+    model: DEFAULT_MODEL,
+    upstream: await client.chatCompletions({ ...chatRequest, model: DEFAULT_MODEL }, signal)
+  };
+}
+function shouldRetryWithDefaultModel(status, text, model) {
+  if (model === DEFAULT_MODEL || status < 400 || status >= 500) {
+    return false;
+  }
+  const normalized = text.toLowerCase();
+  return normalized.includes("model") && (normalized.includes("not supported") || normalized.includes("unsupported") || normalized.includes("invalid model"));
+}
+function requestModel(request) {
+  return typeof request.model === "string" && request.model.trim() ? request.model : DEFAULT_MODEL;
+}
+function textResponse(upstream, text) {
+  const headers = new Headers();
+  const contentType = upstream.headers.get("content-type");
+  if (contentType) {
+    headers.set("content-type", contentType);
+  }
+  return new Response(text, {
+    headers,
+    status: upstream.status,
+    statusText: upstream.statusText
+  });
+}
 async function proxyError(upstream, logger) {
   const text = await upstream.text();
   if (isUpstreamAuthStatus(upstream.status)) {
@@ -1157,6 +1223,15 @@ function jsonError(status, code, message) {
     status
   );
 }
+function websocketUnsupportedResponse() {
+  const response = jsonError(
+    426,
+    "websocket_not_supported",
+    "Hoopilot does not support Responses WebSocket transport; retry with HTTP Responses API."
+  );
+  response.headers.set("upgrade", "websocket");
+  return response;
+}
 function corsHeaders() {
   return {
     "access-control-allow-headers": "authorization, content-type, x-api-key",
@@ -1266,6 +1341,9 @@ function routeFor(method, path) {
   if (method === "POST" && path === "/v1/responses") {
     return "responses";
   }
+  if (method === "GET" && path === "/v1/responses") {
+    return "responses_websocket";
+  }
   return "not_found";
 }
 function isStreamingResponse(response) {