@openhoo/hoopilot 0.5.6 → 0.5.7

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-4.1 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
+codex -m gpt-5.5 -c 'model_reasoning_effort="xhigh"' -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-4.1 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
+$env:OPENAI_API_KEY = "local-key"; codex -m gpt-5.5 -c 'model_reasoning_effort="xhigh"' -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-4.1
+codexx
 ```
 
 Without a global install, run it through npm:
 
 ```powershell
 $env:HOOPILOT_API_KEY = "local-key"
-npx --package @openhoo/hoopilot codexx -m gpt-4.1
+npx --package @openhoo/hoopilot codexx
 ```
 
 `codexx` does not start Hoopilot and does not change your shell environment. It runs
@@ -131,11 +131,13 @@ 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`.
+executable with `CODEXX_CODEX_BIN`, the model with `CODEXX_MODEL`, or the reasoning
+effort with `CODEXX_MODEL_REASONING_EFFORT`.
 
-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`.
+`codexx` defaults to `gpt-5.5` with `model_reasoning_effort="xhigh"`. Codex sends
+those requests through its Responses API provider, and Hoopilot forwards them to
+Copilot's Responses endpoint because `gpt-5.5` is not available through Copilot's
+chat-completions endpoint.
 
 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.
 
@@ -198,7 +200,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-4.1 -c 'openai_base_url="http://127.0.0.1:4141/v1"'
+codex -m gpt-5.5 -c 'model_reasoning_effort="xhigh"' -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.
@@ -240,7 +242,7 @@ Options:
 - `POST /v1/responses`
 - `POST /v1/completions`
 
-`/v1/chat/completions` is proxied to Copilot as directly as possible. `/v1/responses` and `/v1/completions` translate requests and responses to the closest chat completions equivalent, including basic function-tool calls.
+`/v1/chat/completions` and `/v1/responses` are proxied to the matching Copilot endpoints as directly as possible. `/v1/completions` translates legacy completion requests and responses to the closest chat completions equivalent.
 
 ## Development
 

package/dist/cli.js

@@ -339,6 +339,16 @@ var CopilotClient = class {
       signal
     });
   }
+  async responses(body, signal) {
+    return this.fetchCopilot("/responses", {
+      body,
+      headers: {
+        "content-type": "application/json"
+      },
+      method: "POST",
+      signal
+    });
+  }
   async models(signal) {
     return this.fetchCopilot("/models", {
       headers: {
@@ -368,36 +378,6 @@ 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);
-  if (instructions) {
-    messages.push({ content: instructions, role: "system" });
-  }
-  for (const message of inputToMessages(request.input)) {
-    messages.push(message);
-  }
-  return removeUndefined({
-    frequency_penalty: request.frequency_penalty,
-    max_tokens: request.max_output_tokens ?? request.max_tokens,
-    messages,
-    metadata: request.metadata,
-    model: normalizeRequestedModel(request.model),
-    presence_penalty: request.presence_penalty,
-    reasoning_effort: asRecord(request.reasoning).effort,
-    response_format: asRecord(request.text).format,
-    seed: request.seed,
-    stream: request.stream === true,
-    temperature: request.temperature,
-    tool_choice: chatToolChoice(request.tool_choice),
-    tools: chatTools(request.tools),
-    top_p: request.top_p
-  });
-}
 function normalizeChatCompletionRequest(request) {
   return removeUndefined({
     ...request,
@@ -416,38 +396,7 @@ function completionsRequestToChatCompletion(request) {
 }
 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);
-  const message = asRecord(choice.message);
-  const model = contentToText(completion.model) || DEFAULT_MODEL;
-  const output = outputItemsFromMessage(message);
-  const usage = responseUsage(completion.usage);
-  return removeUndefined({
-    created_at: epochSeconds(),
-    error: null,
-    id,
-    incomplete_details: null,
-    instructions: null,
-    max_output_tokens: null,
-    metadata: {},
-    model,
-    object: "response",
-    output,
-    output_text: outputText(output),
-    parallel_tool_calls: true,
-    status: "completed",
-    temperature: null,
-    tool_choice: "auto",
-    tools: [],
-    top_p: null,
-    usage
-  });
+  return requested || DEFAULT_MODEL;
 }
 function chatCompletionToCompletion(completion) {
   const choice = firstChoice(completion);
@@ -492,196 +441,6 @@ function fallbackModels() {
     }
   ];
 }
-function responsesStreamFromChatStream(chatStream, options) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  const responseId = options.responseId ?? `resp_${randomId()}`;
-  const messageId = `msg_${randomId()}`;
-  const createdAt = epochSeconds();
-  let buffer = "";
-  let text = "";
-  const tools = /* @__PURE__ */ new Map();
-  return new ReadableStream({
-    async start(controller) {
-      const enqueue = (event, data) => {
-        controller.enqueue(encoder.encode(encodeSse(event, data)));
-      };
-      enqueue("response.created", {
-        response: baseStreamResponse(responseId, options.model, createdAt, "in_progress", []),
-        type: "response.created"
-      });
-      enqueue("response.output_item.added", {
-        item: {
-          content: [],
-          id: messageId,
-          role: "assistant",
-          status: "in_progress",
-          type: "message"
-        },
-        output_index: 0,
-        type: "response.output_item.added"
-      });
-      enqueue("response.content_part.added", {
-        content_index: 0,
-        item_id: messageId,
-        output_index: 0,
-        part: {
-          annotations: [],
-          text: "",
-          type: "output_text"
-        },
-        type: "response.content_part.added"
-      });
-      const reader = chatStream.getReader();
-      try {
-        while (true) {
-          const result = await reader.read();
-          if (result.done) {
-            break;
-          }
-          buffer += decoder.decode(result.value, { stream: true });
-          const lines = buffer.split(/\r?\n/);
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            processChatSseLine(line, enqueue, tools, (delta) => {
-              text += delta;
-            });
-          }
-        }
-        if (buffer) {
-          processChatSseLine(buffer, enqueue, tools, (delta) => {
-            text += delta;
-          });
-        }
-        const output = streamOutputItems(messageId, text, [...tools.values()]);
-        enqueue("response.output_text.done", {
-          content_index: 0,
-          item_id: messageId,
-          output_index: 0,
-          text,
-          type: "response.output_text.done"
-        });
-        enqueue("response.content_part.done", {
-          content_index: 0,
-          item_id: messageId,
-          output_index: 0,
-          part: {
-            annotations: [],
-            text,
-            type: "output_text"
-          },
-          type: "response.content_part.done"
-        });
-        enqueue("response.output_item.done", {
-          item: output[0],
-          output_index: 0,
-          type: "response.output_item.done"
-        });
-        tools.forEach((tool, index) => {
-          const item = functionCallItem(tool);
-          const outputIndex = index + 1;
-          enqueue("response.output_item.added", {
-            item,
-            output_index: outputIndex,
-            type: "response.output_item.added"
-          });
-          enqueue("response.function_call_arguments.done", {
-            arguments: tool.arguments,
-            item_id: item.id,
-            output_index: outputIndex,
-            type: "response.function_call_arguments.done"
-          });
-          enqueue("response.output_item.done", {
-            item,
-            output_index: outputIndex,
-            type: "response.output_item.done"
-          });
-        });
-        enqueue("response.completed", {
-          response: baseStreamResponse(responseId, options.model, createdAt, "completed", output),
-          type: "response.completed"
-        });
-        enqueue("done", "[DONE]");
-        controller.close();
-      } catch (error) {
-        controller.error(error);
-      } finally {
-        reader.releaseLock();
-      }
-    }
-  });
-}
-function inputToMessages(input) {
-  if (typeof input === "string") {
-    return [{ content: input, role: "user" }];
-  }
-  if (!Array.isArray(input)) {
-    return [];
-  }
-  const messages = [];
-  for (const item of input) {
-    const record = asRecord(item);
-    if (record.type === "function_call_output") {
-      messages.push({
-        content: contentToText(record.output),
-        role: "tool",
-        tool_call_id: contentToText(record.call_id)
-      });
-      continue;
-    }
-    if (record.type === "function_call") {
-      messages.push({
-        role: "assistant",
-        tool_calls: [
-          {
-            function: {
-              arguments: contentToText(record.arguments),
-              name: contentToText(record.name)
-            },
-            id: contentToText(record.call_id) || contentToText(record.id),
-            type: "function"
-          }
-        ]
-      });
-      continue;
-    }
-    const role = roleToChatRole(contentToText(record.role));
-    const content = chatMessageContent(record.content);
-    if (role && content !== void 0) {
-      messages.push({ content, role });
-    }
-  }
-  return messages;
-}
-function chatMessageContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return contentToText(content) || void 0;
-  }
-  const parts = [];
-  for (const part of content) {
-    const record = asRecord(part);
-    const type = contentToText(record.type);
-    if (type === "input_text" || type === "output_text" || type === "text") {
-      parts.push({ text: contentToText(record.text), type: "text" });
-    }
-    if (type === "input_image") {
-      const imageUrl = contentToText(record.image_url);
-      if (imageUrl) {
-        parts.push({ image_url: { url: imageUrl }, type: "image_url" });
-      }
-    }
-  }
-  if (parts.length === 0) {
-    return void 0;
-  }
-  if (parts.every((part) => part.type === "text")) {
-    return parts.map((part) => contentToText(part.text)).join("\n");
-  }
-  return parts;
-}
 function promptToText(prompt) {
   if (Array.isArray(prompt)) {
     return prompt.map((item) => contentToText(item)).join("\n");
@@ -710,188 +469,10 @@ function contentToText(content) {
   }
   return "";
 }
-function roleToChatRole(role) {
-  if (role === "assistant" || role === "developer" || role === "system" || role === "tool") {
-    return role === "developer" ? "system" : role;
-  }
-  return "user";
-}
-function chatTools(tools) {
-  if (!Array.isArray(tools)) {
-    return void 0;
-  }
-  const converted = tools.map((tool) => asRecord(tool)).filter((tool) => tool.type === "function").map((tool) => ({
-    function: removeUndefined({
-      description: tool.description,
-      name: tool.name,
-      parameters: tool.parameters,
-      strict: tool.strict
-    }),
-    type: "function"
-  }));
-  return converted.length > 0 ? converted : void 0;
-}
-function chatToolChoice(toolChoice) {
-  if (typeof toolChoice === "string" || toolChoice === void 0) {
-    return toolChoice;
-  }
-  const record = asRecord(toolChoice);
-  if (record.type === "function" && typeof record.name === "string") {
-    return { function: { name: record.name }, type: "function" };
-  }
-  return toolChoice;
-}
-function outputItemsFromMessage(message) {
-  const output = [];
-  const text = contentToText(message.content);
-  if (text) {
-    output.push(messageOutputItem(text));
-  }
-  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-  for (const toolCall of toolCalls) {
-    const record = asRecord(toolCall);
-    const fn = asRecord(record.function);
-    output.push(
-      functionCallItem({
-        arguments: contentToText(fn.arguments),
-        id: contentToText(record.id) || `call_${randomId()}`,
-        index: output.length,
-        name: contentToText(fn.name)
-      })
-    );
-  }
-  return output;
-}
-function messageOutputItem(text, id = `msg_${randomId()}`) {
-  return {
-    content: [
-      {
-        annotations: [],
-        text,
-        type: "output_text"
-      }
-    ],
-    id,
-    role: "assistant",
-    status: "completed",
-    type: "message"
-  };
-}
-function functionCallItem(tool) {
-  return {
-    arguments: tool.arguments,
-    call_id: tool.id,
-    id: `fc_${randomId()}`,
-    name: tool.name,
-    status: "completed",
-    type: "function_call"
-  };
-}
-function outputText(output) {
-  return output.flatMap((item) => {
-    const content = item.content;
-    return Array.isArray(content) ? content : [];
-  }).map((part) => contentToText(asRecord(part).text)).filter(Boolean).join("");
-}
-function responseUsage(usage) {
-  const record = asRecord(usage);
-  if (Object.keys(record).length === 0) {
-    return null;
-  }
-  return removeUndefined({
-    input_tokens: record.prompt_tokens,
-    input_tokens_details: record.prompt_tokens_details,
-    output_tokens: record.completion_tokens,
-    output_tokens_details: record.completion_tokens_details,
-    total_tokens: record.total_tokens
-  });
-}
 function firstChoice(completion) {
   const choices = Array.isArray(completion.choices) ? completion.choices : [];
   return asRecord(choices[0]);
 }
-function processChatSseLine(line, enqueue, tools, appendText) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith("data:")) {
-    return;
-  }
-  const data = trimmed.slice("data:".length).trim();
-  if (!data || data === "[DONE]") {
-    return;
-  }
-  const parsed = parseJson(data);
-  if (!parsed) {
-    return;
-  }
-  const choice = firstChoice(parsed);
-  const delta = asRecord(choice.delta);
-  const content = contentToText(delta.content);
-  if (content) {
-    appendText(content);
-    enqueue("response.output_text.delta", {
-      content_index: 0,
-      delta: content,
-      item_id: "",
-      output_index: 0,
-      type: "response.output_text.delta"
-    });
-  }
-  const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-  for (const toolCall of toolCalls) {
-    const record = asRecord(toolCall);
-    const fn = asRecord(record.function);
-    const index = typeof record.index === "number" ? record.index : tools.size;
-    const existing = tools.get(index) ?? {
-      arguments: "",
-      id: contentToText(record.id) || `call_${randomId()}`,
-      index,
-      name: ""
-    };
-    existing.id = contentToText(record.id) || existing.id;
-    existing.name += contentToText(fn.name);
-    existing.arguments += contentToText(fn.arguments);
-    tools.set(index, existing);
-  }
-}
-function streamOutputItems(messageId, text, tools) {
-  return [messageOutputItem(text, messageId), ...tools.map((tool) => functionCallItem(tool))];
-}
-function baseStreamResponse(id, model, createdAt, status, output) {
-  return {
-    created_at: createdAt,
-    error: null,
-    id,
-    incomplete_details: null,
-    instructions: null,
-    max_output_tokens: null,
-    metadata: {},
-    model,
-    object: "response",
-    output,
-    parallel_tool_calls: true,
-    status,
-    temperature: null,
-    tool_choice: "auto",
-    tools: [],
-    top_p: null
-  };
-}
-function encodeSse(event, data) {
-  if (data === "[DONE]") {
-    return "data: [DONE]\n\n";
-  }
-  return `event: ${event}
-data: ${JSON.stringify(data)}
-
-`;
-}
-function parseJson(data) {
-  try {
-    return asRecord(JSON.parse(data));
-  } catch {
-    return void 0;
-  }
-}
 function removeUndefined(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
 }
@@ -1070,8 +651,7 @@ async function handleModels(client, signal, logger) {
 }
 async function handleChatCompletions(client, request, logger) {
   const chatRequest = normalizeChatCompletionRequest(await readJson(request));
-  const result = await sendChatCompletions(client, chatRequest, request.signal, logger);
-  const upstream = result.upstream;
+  const upstream = await client.chatCompletions(chatRequest, request.signal);
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
@@ -1080,13 +660,10 @@ async function handleChatCompletions(client, request, logger) {
 }
 async function handleCompletions(client, request, logger) {
   const body = await readJson(request);
-  const result = await sendChatCompletions(
-    client,
+  const upstream = await client.chatCompletions(
     completionsRequestToChatCompletion(body),
-    request.signal,
-    logger
+    request.signal
   );
-  const upstream = result.upstream;
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
@@ -1094,76 +671,13 @@ async function handleCompletions(client, request, logger) {
   return jsonResponse(chatCompletionToCompletion(await upstream.json()));
 }
 async function handleResponses(client, request, logger) {
-  const body = await readJson(request);
-  const chatRequest = responsesRequestToChatCompletion(body);
-  const result = await sendChatCompletions(client, chatRequest, request.signal, logger);
-  const upstream = result.upstream;
+  const body = await readJsonText(request);
+  const upstream = await client.responses(body, request.signal);
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
-  logUpstreamSuccess(logger, "/chat/completions", upstream.status);
-  if (body.stream === true && upstream.body) {
-    return new Response(
-      responsesStreamFromChatStream(upstream.body, {
-        model: result.model
-      }),
-      {
-        headers: {
-          ...corsHeaders(),
-          "cache-control": "no-cache",
-          connection: "keep-alive",
-          "content-type": "text/event-stream; charset=utf-8"
-        }
-      }
-    );
-  }
-  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
-  });
+  logUpstreamSuccess(logger, "/responses", upstream.status);
+  return proxyResponse(upstream);
 }
 async function proxyError(upstream, logger) {
   const text = await upstream.text();
@@ -1202,6 +716,15 @@ async function readJson(request) {
     throw new Error(INVALID_JSON_MESSAGE);
   }
 }
+async function readJsonText(request) {
+  const text = await request.text();
+  try {
+    JSON.parse(text);
+    return text;
+  } catch {
+    throw new Error(INVALID_JSON_MESSAGE);
+  }
+}
 function jsonResponse(body, status = 200) {
   return new Response(JSON.stringify(body), {
     headers: {