feat: add event logging and Codex CLI responses endpoints

- Add /api/event_logging/batch endpoint returning 200 (PR ericc-ch#165)
- Add /v1/responses endpoint for OpenAI Codex CLI support (PR ericc-ch#195)
- Create response service with streaming support

Co-authored-by: Zevan770 <Zevan770@users.noreply.github.com>
Co-authored-by: albanx <albanx@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 4 people

src/routes/event-logging/route.ts

@@ -0,0 +1,16 @@
+/**
+ * Anthropic Event Logging Endpoint
+ * PR #165: Add Anthropic event logging endpoint (@Zevan770)
+ *
+ * This endpoint returns 200 for /api/event_logging/batch to satisfy
+ * Anthropic clients that expect this endpoint to exist.
+ */
+
+import { Hono } from "hono"
+
+export const eventLoggingRoute = new Hono()
+
+// Accept event logging batch requests and return 200
+eventLoggingRoute.post("/batch", (c) => {
+  return c.json({ status: "ok" }, 200)
+})

src/routes/responses/handler.ts

@@ -0,0 +1,45 @@
+/**
+ * Responses API Handler
+ * PR #195: Add Codex CLI support (@albanx)
+ *
+ * Handles the /v1/responses endpoint for OpenAI Codex CLI compatibility.
+ */
+
+import type { Context } from "hono"
+
+import consola from "consola"
+import { streamSSE, type SSEMessage } from "hono/streaming"
+
+import { checkRateLimit } from "~/lib/rate-limit"
+import { state } from "~/lib/state"
+import {
+  createResponse,
+  type ResponseOutput,
+  type ResponsesPayload,
+} from "~/services/copilot/create-response"
+
+export async function handleResponse(c: Context) {
+  await checkRateLimit(state)
+
+  const payload = await c.req.json<ResponsesPayload>()
+  consola.debug("Responses API payload:", JSON.stringify(payload).slice(-400))
+
+  const response = await createResponse(payload)
+
+  if (isNonStreaming(response)) {
+    consola.debug("Non-streaming response:", JSON.stringify(response))
+    return c.json(response)
+  }
+
+  consola.debug("Streaming response")
+  return streamSSE(c, async (stream) => {
+    for await (const chunk of response) {
+      consola.debug("Streaming chunk:", JSON.stringify(chunk))
+      await stream.writeSSE(chunk as SSEMessage)
+    }
+  })
+}
+
+const isNonStreaming = (
+  response: Awaited<ReturnType<typeof createResponse>>,
+): response is ResponseOutput => Object.hasOwn(response, "output")

src/routes/responses/route.ts

@@ -0,0 +1,14 @@
+/**
+ * Responses API Route
+ * PR #195: Add Codex CLI support (@albanx)
+ *
+ * This endpoint provides /v1/responses compatibility for OpenAI Codex CLI.
+ */
+
+import { Hono } from "hono"
+
+import { handleResponse } from "./handler"
+
+export const responsesRoute = new Hono()
+
+responsesRoute.post("/", handleResponse)

src/server.ts

@@ -5,8 +5,10 @@ import { logger } from "hono/logger"
 import { apiKeyAuth } from "./lib/api-key-auth"
 import { completionRoutes } from "./routes/chat-completions/route"
 import { embeddingRoutes } from "./routes/embeddings/route"
+import { eventLoggingRoute } from "./routes/event-logging/route"
 import { messageRoutes } from "./routes/messages/route"
 import { modelRoutes } from "./routes/models/route"
+import { responsesRoute } from "./routes/responses/route"
 import { tokenRoute } from "./routes/token/route"
 import { usageRoute } from "./routes/usage/route"
 
@@ -23,6 +25,7 @@ server.use("/chat/*", apiKeyAuth)
 server.use("/models/*", apiKeyAuth)
 server.use("/embeddings/*", apiKeyAuth)
 server.use("/v1/*", apiKeyAuth)
+server.use("/api/*", apiKeyAuth)
 
 server.route("/chat/completions", completionRoutes)
 server.route("/models", modelRoutes)
@@ -37,3 +40,9 @@ server.route("/v1/embeddings", embeddingRoutes)
 
 // Anthropic compatible endpoints
 server.route("/v1/messages", messageRoutes)
+
+// PR #165: Anthropic event logging endpoint (@Zevan770)
+server.route("/api/event_logging", eventLoggingRoute)
+
+// PR #195: Codex CLI responses endpoint (@albanx)
+server.route("/v1/responses", responsesRoute)

src/services/copilot/create-response.ts

@@ -0,0 +1,100 @@
+/**
+ * Create Responses Service
+ * PR #195: Add Codex CLI support (@albanx)
+ *
+ * This service handles the /v1/responses endpoint for OpenAI Codex CLI compatibility.
+ * The Codex CLI requires this endpoint to function properly.
+ *
+ * Docs:
+ * - https://developers.openai.com/codex/config-advanced
+ * - https://github.com/openai/codex/discussions/7782
+ */
+
+import consola from "consola"
+import { events } from "fetch-event-stream"
+
+import { copilotBaseUrl, copilotHeaders } from "~/lib/api-config"
+import { HTTPError } from "~/lib/error"
+import { state } from "~/lib/state"
+
+export interface ResponsesPayload {
+  model: string
+  input: string | Array<ResponseInputItem>
+  instructions?: string
+  max_output_tokens?: number
+  temperature?: number
+  top_p?: number
+  stream?: boolean
+  tools?: Array<ResponseTool>
+  tool_choice?:
+    | "auto"
+    | "none"
+    | "required"
+    | { type: "function"; name: string }
+  reasoning?: {
+    effort?: "low" | "medium" | "high"
+  }
+  truncation?: "auto" | "disabled"
+}
+
+export interface ResponseInputItem {
+  type: "message" | "item_reference"
+  role?: "user" | "assistant" | "system"
+  content?: string | Array<{ type: "input_text"; text: string }>
+  id?: string
+}
+
+export interface ResponseTool {
+  type: "function"
+  name: string
+  description?: string
+  parameters?: Record<string, unknown>
+}
+
+export interface ResponseOutput {
+  id: string
+  object: "response"
+  created_at: number
+  model: string
+  output: Array<ResponseOutputItem>
+  usage?: {
+    input_tokens: number
+    output_tokens: number
+    total_tokens: number
+  }
+  status: "completed" | "failed" | "cancelled" | "incomplete"
+}
+
+export interface ResponseOutputItem {
+  type: "message"
+  id: string
+  role: "assistant"
+  content: Array<{ type: "output_text"; text: string }>
+}
+
+export const createResponse = async (payload: ResponsesPayload) => {
+  if (!state.copilotToken) throw new Error("Copilot token not found")
+
+  const headers: Record<string, string> = {
+    ...copilotHeaders(state, false),
+    "X-Initiator": "agent",
+  }
+
+  // Copilot uses /responses endpoint
+  const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+  })
+
+  if (!response.ok) {
+    consola.error("Failed to create response", response)
+    throw new HTTPError("Failed to create response", response)
+  }
+
+  if (payload.stream) {
+    return events(response)
+  }
+
+  return (await response.json()) as ResponseOutput
+}