@yansigit/opencodex 2.31.0

package/src/chat/inbound.ts

@@ -0,0 +1,319 @@
+/**
+ * Chat Completions inbound: OpenAI-compatible request -> internal /v1/responses body.
+ *
+ * Used by GitHub Copilot App (and other OpenAI-compatible clients) via POST /v1/chat/completions.
+ * Same translate-and-replay pattern as Claude Messages: the produced body must pass
+ * responsesRequestSchema so routing/OAuth/pool/sidecars are inherited unchanged.
+ */
+export class ChatCompletionsRequestError extends Error {}
+
+type Rec = Record<string, unknown>;
+type ChatCompletionsRoutingBody = Rec & { model: string; messages: unknown[] };
+
+function isRec(v: unknown): v is Rec {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+/** Validate only the fields needed before Chat routing, without projecting the body. */
+export function assertChatCompletionsRoutingBody(raw: unknown): asserts raw is ChatCompletionsRoutingBody {
+  if (!isRec(raw)) throw new ChatCompletionsRequestError("request body must be a JSON object");
+  if (typeof raw.model !== "string" || raw.model.length === 0) {
+    throw new ChatCompletionsRequestError("model is required");
+  }
+  if (!Array.isArray(raw.messages) || raw.messages.length === 0) {
+    throw new ChatCompletionsRequestError("messages must be a non-empty array");
+  }
+}
+
+const OUTPUT_CONFIG_EFFORTS = new Set(["minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
+const OUTPUT_CONFIG_SUMMARIES = new Set(["auto", "concise", "detailed", "none"]);
+
+function contentToText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const raw of content) {
+    if (typeof raw === "string") {
+      parts.push(raw);
+      continue;
+    }
+    if (!isRec(raw)) continue;
+    if ((raw.type === "text" || raw.type === "input_text" || raw.type === "output_text") && typeof raw.text === "string") {
+      parts.push(raw.text);
+    }
+  }
+  return parts.join("\n");
+}
+
+function imageUrlFromPart(part: Rec): string | null {
+  if (part.type !== "image_url") return null;
+  const imageUrl = part.image_url;
+  if (typeof imageUrl === "string" && imageUrl.length > 0) return imageUrl;
+  if (isRec(imageUrl) && typeof imageUrl.url === "string" && imageUrl.url.length > 0) return imageUrl.url;
+  return null;
+}
+
+function userContentToBlocks(content: unknown): Rec[] {
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "input_text", text: content }] : [];
+  }
+  if (!Array.isArray(content)) return [];
+  const blocks: Rec[] = [];
+  for (const raw of content) {
+    if (typeof raw === "string") {
+      if (raw.length > 0) blocks.push({ type: "input_text", text: raw });
+      continue;
+    }
+    if (!isRec(raw)) continue;
+    if ((raw.type === "text" || raw.type === "input_text") && typeof raw.text === "string") {
+      blocks.push({ type: "input_text", text: raw.text });
+      continue;
+    }
+    const imageUrl = imageUrlFromPart(raw);
+    if (imageUrl) blocks.push({ type: "input_image", image_url: imageUrl });
+  }
+  return blocks;
+}
+
+function assistantContentToBlocks(content: unknown): Rec[] {
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "output_text", text: content }] : [];
+  }
+  if (!Array.isArray(content)) return [];
+  const blocks: Rec[] = [];
+  for (const raw of content) {
+    if (typeof raw === "string") {
+      if (raw.length > 0) blocks.push({ type: "output_text", text: raw });
+      continue;
+    }
+    if (!isRec(raw)) continue;
+    if ((raw.type === "text" || raw.type === "output_text") && typeof raw.text === "string") {
+      blocks.push({ type: "output_text", text: raw.text });
+    }
+  }
+  return blocks;
+}
+
+function pushSystemText(parts: string[], content: unknown): void {
+  const text = contentToText(content).trim();
+  if (text) parts.push(text);
+}
+
+function toolCallsToItems(toolCalls: unknown, input: Rec[], knownNameByCallId: Map<string, string>): void {
+  if (!Array.isArray(toolCalls)) return;
+  for (const raw of toolCalls) {
+    if (!isRec(raw)) continue;
+    const fn = isRec(raw.function) ? raw.function : null;
+    let name = typeof fn?.name === "string" ? fn.name : typeof raw.name === "string" ? raw.name : "";
+    const args = typeof fn?.arguments === "string"
+      ? fn.arguments
+      : typeof raw.arguments === "string"
+        ? raw.arguments
+        : JSON.stringify(fn?.arguments ?? raw.arguments ?? {});
+    const callId = typeof raw.id === "string" && raw.id.length > 0
+      ? raw.id
+      : typeof raw.call_id === "string" && raw.call_id.length > 0
+        ? raw.call_id
+        : `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+    if (!name) name = knownNameByCallId.get(callId) ?? "";
+    if (!name) throw new ChatCompletionsRequestError("tool_calls entries require function.name");
+    knownNameByCallId.set(callId, name);
+    input.push({ type: "function_call", call_id: callId, name, arguments: args });
+  }
+}
+
+function toolsToResponses(tools: unknown): Rec[] | undefined {
+  if (!Array.isArray(tools) || tools.length === 0) return undefined;
+  const out: Rec[] = [];
+  for (const raw of tools) {
+    if (!isRec(raw)) continue;
+    if (raw.type === "function" && typeof raw.name === "string" && raw.name.length > 0) {
+      out.push({
+        type: "function",
+        name: raw.name,
+        ...(typeof raw.description === "string" ? { description: raw.description } : {}),
+        ...(isRec(raw.parameters) ? { parameters: raw.parameters } : {}),
+        ...(typeof raw.strict === "boolean" ? { strict: raw.strict } : {}),
+      });
+      continue;
+    }
+    if (raw.type === "function" && isRec(raw.function) && typeof raw.function.name === "string" && raw.function.name.length > 0) {
+      out.push({
+        type: "function",
+        name: raw.function.name,
+        ...(typeof raw.function.description === "string" ? { description: raw.function.description } : {}),
+        ...(isRec(raw.function.parameters) ? { parameters: raw.function.parameters } : {}),
+        ...(typeof raw.function.strict === "boolean" ? { strict: raw.function.strict } : {}),
+      });
+      continue;
+    }
+    if (raw.type === "web_search" || raw.type === "web_search_preview") {
+      out.push({ type: "web_search" });
+    }
+  }
+  return out.length > 0 ? out : undefined;
+}
+
+function toolChoiceToResponses(choice: unknown, body: Rec): void {
+  if (choice === undefined || choice === null) return;
+  if (choice === "auto" || choice === "none" || choice === "required") {
+    body.tool_choice = choice;
+    return;
+  }
+  if (!isRec(choice)) return;
+  if (choice.type === "function") {
+    const name = typeof choice.name === "string"
+      ? choice.name
+      : isRec(choice.function) && typeof choice.function.name === "string"
+        ? choice.function.name
+        : "";
+    if (!name) throw new ChatCompletionsRequestError("tool_choice.function requires a name");
+    body.tool_choice = { type: "function", name };
+    return;
+  }
+  if (isRec(choice.function) && typeof choice.function.name === "string") {
+    body.tool_choice = { type: "function", name: choice.function.name };
+  }
+}
+
+function responseFormatToText(format: unknown): Rec | undefined {
+  if (format === undefined) return undefined;
+  if (!isRec(format)) throw new ChatCompletionsRequestError("response_format must be an object");
+  if (format.type === "json_object") return { format: { type: "json_object" } };
+  if (format.type === "json_schema") {
+    if (!isRec(format.json_schema)) {
+      throw new ChatCompletionsRequestError("response_format.json_schema is required for type json_schema");
+    }
+    const schema = format.json_schema;
+    return {
+      format: {
+        type: "json_schema",
+        name: typeof schema.name === "string" ? schema.name : "response",
+        ...(typeof schema.description === "string" ? { description: schema.description } : {}),
+        ...(schema.schema !== undefined ? { schema: schema.schema } : {}),
+        ...(typeof schema.strict === "boolean" ? { strict: schema.strict } : {}),
+      },
+    };
+  }
+  if (format.type === "text") return undefined;
+  throw new ChatCompletionsRequestError(`unsupported response_format.type: ${String(format.type)}`);
+}
+
+function resolveReasoningEffort(raw: Rec): string | undefined {
+  if (typeof raw.reasoning_effort === "string" && OUTPUT_CONFIG_EFFORTS.has(raw.reasoning_effort)) {
+    return raw.reasoning_effort;
+  }
+  if (isRec(raw.reasoning) && typeof raw.reasoning.effort === "string" && OUTPUT_CONFIG_EFFORTS.has(raw.reasoning.effort)) {
+    return raw.reasoning.effort;
+  }
+  return undefined;
+}
+
+/**
+ * Chat Completions clients (Grok Build, Copilot, OpenAI-compatible SDKs) expect
+ * `delta.reasoning_content` whenever the model thinks. The internal Responses
+ * parser hides thinking unless `reasoning.summary` is set and is not `"none"`.
+ * Map the common Chat Completions knobs onto that field. When the client only
+ * sent an effort, default the summary to `"auto"` so traces are not swallowed.
+ */
+function resolveReasoningSummary(raw: Rec): string | undefined {
+  if (isRec(raw.reasoning) && typeof raw.reasoning.summary === "string" && OUTPUT_CONFIG_SUMMARIES.has(raw.reasoning.summary)) {
+    return raw.reasoning.summary;
+  }
+  if (raw.include_reasoning === false) return "none";
+  if (raw.include_reasoning === true) return "auto";
+  return undefined;
+}
+
+/**
+ * Translate an OpenAI Chat Completions request body into a /v1/responses request body.
+ * Throws ChatCompletionsRequestError (-> 400) on malformed input.
+ */
+export function chatCompletionsToResponsesBody(raw: unknown): Rec {
+  assertChatCompletionsRoutingBody(raw);
+
+  const systemParts: string[] = [];
+  const input: Rec[] = [];
+  // Recover replace-style tool calls incrementally instead of rebuilding the
+  // call-id index from the entire translated transcript for every message.
+  const knownNameByCallId = new Map<string, string>();
+
+  for (const msg of raw.messages) {
+    if (!isRec(msg)) continue;
+    const role = typeof msg.role === "string" ? msg.role : "";
+    switch (role) {
+      case "system":
+      case "developer":
+        pushSystemText(systemParts, msg.content);
+        break;
+      case "user": {
+        const blocks = userContentToBlocks(msg.content);
+        if (blocks.length > 0) input.push({ type: "message", role: "user", content: blocks });
+        break;
+      }
+      case "assistant": {
+        const blocks = assistantContentToBlocks(msg.content);
+        if (blocks.length > 0) input.push({ type: "message", role: "assistant", content: blocks });
+        if (msg.tool_calls !== undefined) toolCallsToItems(msg.tool_calls, input, knownNameByCallId);
+        break;
+      }
+      case "tool": {
+        const callId = typeof msg.tool_call_id === "string" ? msg.tool_call_id
+          : typeof msg.tool_use_id === "string" ? msg.tool_use_id
+          : "";
+        if (!callId) throw new ChatCompletionsRequestError("tool messages require tool_call_id");
+        const output = typeof msg.content === "string" ? msg.content : contentToText(msg.content);
+        input.push({ type: "function_call_output", call_id: callId, output });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  if (input.length === 0 && systemParts.length === 0) {
+    throw new ChatCompletionsRequestError("messages must include at least one user/assistant/tool turn");
+  }
+
+  const body: Rec = {
+    model: raw.model,
+    input,
+    stream: raw.stream === true,
+    store: false,
+  };
+
+  if (systemParts.length > 0) body.instructions = systemParts.join("\n\n");
+
+  const tools = toolsToResponses(raw.tools);
+  if (tools) body.tools = tools;
+  toolChoiceToResponses(raw.tool_choice, body);
+
+  const maxTokens = typeof raw.max_completion_tokens === "number"
+    ? raw.max_completion_tokens
+    : typeof raw.max_tokens === "number"
+      ? raw.max_tokens
+      : undefined;
+  if (typeof maxTokens === "number") body.max_output_tokens = maxTokens;
+  if (typeof raw.temperature === "number") body.temperature = raw.temperature;
+  if (typeof raw.top_p === "number") body.top_p = raw.top_p;
+  if (raw.stop !== undefined) body.stop = raw.stop;
+  if (typeof raw.user === "string") body.user = raw.user;
+  if (typeof raw.parallel_tool_calls === "boolean") body.parallel_tool_calls = raw.parallel_tool_calls;
+  if (typeof raw.service_tier === "string") body.service_tier = raw.service_tier;
+  if (typeof raw.prompt_cache_key === "string") body.prompt_cache_key = raw.prompt_cache_key;
+  if (raw.metadata !== undefined) body.metadata = raw.metadata;
+
+  const effort = resolveReasoningEffort(raw);
+  const summary = resolveReasoningSummary(raw);
+  if (effort || summary !== undefined) {
+    body.reasoning = {
+      ...(effort ? { effort } : {}),
+      summary: summary ?? "auto",
+    };
+  }
+
+  const text = responseFormatToText(raw.response_format);
+  if (text) body.text = text;
+
+  return body;
+}