initial openrouter wrapper

Author: charleslien

npm-app/package.json

@@ -34,6 +34,7 @@
     "bun": ">=1.2.11"
   },
   "dependencies": {
+    "@ai-sdk/openai-compatible": "^1.0.19",
     "@codebuff/code-map": "workspace:*",
     "@codebuff/common": "workspace:*",
     "@types/diff": "8.0.0",

npm-app/src/asdf.ts

@@ -0,0 +1,35 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible'
+import { streamText } from 'ai'
+
+import { websiteUrl } from './config'
+
+const codebuffBackendProvider = createOpenAICompatible({
+  name: 'codebuff',
+  apiKey: '12345',
+  baseURL: websiteUrl + '/api/v1',
+})
+
+const response = streamText({
+  model: codebuffBackendProvider('anthropic/claude-sonnet-4.5'),
+  messages: [
+    {
+      role: 'user',
+      content:
+        'This is a bunch of text just to fill out some space. Ignore this.'.repeat(
+          1000,
+        ),
+    },
+    {
+      role: 'user',
+      content: 'Hello',
+      providerOptions: {
+        codebuff: {
+          cacheControl: { type: 'ephemeral' },
+        },
+      },
+    },
+  ],
+})
+for await (const chunk of response.fullStream) {
+  console.log('asdf', { chunk })
+}

web/src/app/api/v1/chat/completions/route.ts

@@ -0,0 +1,73 @@
+import { NextResponse } from 'next/server'
+
+import type { NextRequest } from 'next/server'
+
+import { getUserInfoFromApiKey } from '@/db/user'
+import { handleOpenrouterStream } from '@/llm-api/openrouter'
+import { extractApiKeyFromHeader } from '@/util/auth'
+import { errorToObject } from '@/util/error'
+import { logger } from '@/util/logger'
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json()
+
+    console.log('asdf', {
+      req: { headers: Object.fromEntries(req.headers), body },
+    })
+
+    const apiKey = extractApiKeyFromHeader(req)
+
+    if (!apiKey) {
+      return NextResponse.json({ message: 'Unauthorized' }, { status: 401 })
+    }
+
+    const userInfo = await getUserInfoFromApiKey({ apiKey, fields: ['id'] })
+    if (!userInfo) {
+      return NextResponse.json(
+        { message: 'Invalid Codebuff API key' },
+        { status: 401 }
+      )
+    }
+
+    if (body.stream) {
+      try {
+        const stream = await handleOpenrouterStream({
+          body,
+        })
+
+        return new NextResponse(stream, {
+          headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+          },
+        })
+      } catch (error) {
+        logger.error(
+          errorToObject(error),
+          'Error setting up OpenRouter stream:'
+        )
+        return NextResponse.json(
+          { error: 'Failed to initialize stream' },
+          { status: 500 }
+        )
+      }
+    }
+
+    return NextResponse.json(
+      { message: 'Not implemented. Use stream=true.' },
+      { status: 500 }
+    )
+  } catch (error) {
+    logger.error(
+      errorToObject(error),
+      'Error processing chat completions request:'
+    )
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

web/src/db/user.ts

@@ -0,0 +1,39 @@
+import db from '@codebuff/common/db'
+import * as schema from '@codebuff/common/db/schema'
+import { eq } from 'drizzle-orm'
+
+import type { InferSelectModel } from 'drizzle-orm'
+
+type UserTable = typeof schema.user
+type UserColumn = UserTable['_']['columns']
+type User = InferSelectModel<UserTable>
+
+export async function getUserInfoFromApiKey<
+  T extends readonly (keyof UserColumn)[],
+>({
+  apiKey,
+  fields,
+}: {
+  apiKey: string
+  fields: T
+}): Promise<
+  | {
+      [K in T[number]]: User[K]
+    }
+  | undefined
+> {
+  // Build a typed selection object for user columns
+  const userSelection = Object.fromEntries(
+    fields.map((field) => [field, schema.user[field]])
+  ) as { [K in T[number]]: UserColumn[K] }
+
+  const rows = await db
+    .select({ user: userSelection }) // <-- important: nest under 'user'
+    .from(schema.user)
+    .leftJoin(schema.session, eq(schema.user.id, schema.session.userId))
+    .where(eq(schema.session.sessionToken, apiKey))
+    .limit(1)
+
+  // Drizzle returns { user: ..., session: ... }, we return only the user part
+  return rows[0]?.user
+}

web/src/llm-api/openrouter.ts

@@ -0,0 +1,92 @@
+import { env } from '@codebuff/internal/env'
+
+export async function handleOpenrouterStream({ body }: { body: any }) {
+  // Ensure usage tracking is enabled
+  if (body.usage === undefined) {
+    body.usage = {}
+  }
+  body.usage.include = true
+
+  const response = await fetch(
+    'https://openrouter.ai/api/v1/chat/completions',
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${env.OPEN_ROUTER_API_KEY}`,
+        'HTTP-Referer': 'https://codebuff.com',
+        'X-Title': 'Codebuff',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    }
+  )
+
+  if (!response.ok) {
+    throw new Error(`OpenRouter API error: ${response.statusText}`)
+  }
+
+  const reader = response.body?.getReader()
+  if (!reader) {
+    throw new Error('Failed to get response reader')
+  }
+
+  let heartbeatInterval: ReturnType<typeof setInterval>
+
+  // Create a ReadableStream that Next.js can handle
+  const stream = new ReadableStream({
+    async start(controller) {
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      // Send initial connection message
+      controller.enqueue(
+        new TextEncoder().encode(`: connected ${new Date().toISOString()}\n`)
+      )
+
+      // Start heartbeat
+      heartbeatInterval = setInterval(() => {
+        controller.enqueue(
+          new TextEncoder().encode(
+            `: heartbeat ${new Date().toISOString()}\n\n`
+          )
+        )
+      }, 30000)
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+
+          if (done) {
+            break
+          }
+
+          buffer += decoder.decode(value, { stream: true })
+          let lineEnd = buffer.indexOf('\n')
+
+          while (lineEnd !== -1) {
+            const line = buffer.slice(0, lineEnd + 1)
+            buffer = buffer.slice(lineEnd + 1)
+
+            // Forward the line to the client
+            controller.enqueue(new TextEncoder().encode(line))
+
+            lineEnd = buffer.indexOf('\n')
+          }
+        }
+
+        controller.close()
+      } catch (error) {
+        controller.error(error)
+      } finally {
+        clearInterval(heartbeatInterval)
+        reader.cancel()
+      }
+    },
+    cancel() {
+      clearInterval(heartbeatInterval)
+      reader.cancel()
+    },
+  })
+
+  return stream
+}

web/src/util/auth.ts

@@ -0,0 +1,20 @@
+import type { NextRequest } from 'next/server'
+
+/**
+ * Extract api key from x-codebuff-api-key header or authorization header
+ */
+export function extractApiKeyFromHeader(req: NextRequest): string | undefined {
+  const token = req.headers.get('x-codebuff-api-key')
+  if (typeof token === 'string' && token) {
+    return token
+  }
+
+  const authorization = req.headers.get('Authorization')
+  if (!authorization) {
+    return undefined
+  }
+  if (!authorization.startsWith('Bearer ')) {
+    return undefined
+  }
+  return authorization.slice('Bearer '.length)
+}

web/src/util/error.ts

@@ -0,0 +1,17 @@
+export function errorToObject(error: any): object {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    }
+  }
+
+  if (typeof error === 'string') {
+    return {
+      message: error,
+    }
+  }
+
+  return error
+}