@openhoo/hoopilot 0.5.5 → 0.5.6

package/README.md

@@ -101,27 +101,27 @@ 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 runs
@@ -133,6 +133,10 @@ spawned Codex process so Codex talks directly to the local server. Override the
 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
@@ -194,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);
@@ -1062,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);
   }
@@ -1071,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);
   }
@@ -1084,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);
   }
@@ -1092,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: {
@@ -1106,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)) {