first upload

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "gcli_oai_proxy",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@google/gemini-cli": "^0.1.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}

src/chatwrapper.ts

@@ -0,0 +1,69 @@
+// src/chatwrapper.ts
+import {
+  AuthType,
+  createContentGeneratorConfig,
+  createContentGenerator,
+} from '@google/gemini-cli-core/dist/src/core/contentGenerator.js';
+
+/* ------------------------------------------------------------------ */
+/* 1.  Build the ContentGenerator exactly like the CLI does           */
+/* ------------------------------------------------------------------ */
+let modelName: string;                      // we'll fill this once
+const generatorPromise = (async () => {
+  // Pass undefined for model so the helper falls back to DEFAULT_GEMINI_MODEL
+  const cfg = await createContentGeneratorConfig(
+    undefined,                     // let helper pick default (Gemini-2.5-Pro)
+    AuthType.USE_GEMINI            // same mode the CLI defaults to
+  );
+  modelName = cfg.model;           // remember the actual model string
+  return await createContentGenerator(cfg);
+})();
+
+/* ------------------------------------------------------------------ */
+/* 2.  Helpers consumed by server.ts                                   */
+/* ------------------------------------------------------------------ */
+type GenConfig = Record<string, unknown>;
+
+export async function sendChat({
+  contents,
+  generationConfig = {},
+}: {
+  contents: any[];
+  generationConfig?: GenConfig;
+  tools?: unknown;                // accepted but ignored for now
+}) {
+  const generator: any = await generatorPromise;
+  return await generator.generateContent({
+    model: modelName,
+    contents,
+    config: generationConfig,
+  });
+}
+
+export async function* sendChatStream({
+  contents,
+  generationConfig = {},
+}: {
+  contents: any[];
+  generationConfig?: GenConfig;
+  tools?: unknown;
+}) {
+  const generator: any = await generatorPromise;
+  const stream = await generator.generateContentStream({
+    model: modelName,
+    contents,
+    config: generationConfig,
+  });
+  for await (const chunk of stream) yield chunk;
+}
+
+/* ------------------------------------------------------------------ */
+/* 3.  Minimal stubs so server.ts compiles (extend later)              */
+/* ------------------------------------------------------------------ */
+export function listModels() {
+  return [{ id: modelName }];
+}
+
+export async function embed(_input: unknown) {
+  throw new Error('Embeddings endpoint not implemented yet.');
+}

src/mapper.ts

@@ -0,0 +1,124 @@
+/* ------------------------------------------------------------------ */
+/*  mapper.ts – OpenAI ⇆ Gemini (with reasoning/1 M context)           */
+/* ------------------------------------------------------------------ */
+import { fetchAndEncode } from './remoteimage';
+import { z } from 'zod';
+import { ToolRegistry } from '@google/gemini-cli-core/dist/src/tools/tool-registry.js';
+
+/* ------------------------------------------------------------------ */
+type Part = { text?: string; inlineData?: { mimeType: string; data: string } };
+
+/* ------------------------------------------------------------------ */
+async function callLocalFunction(_name: string, _args: unknown) {
+  return { ok: true };
+}
+
+/* ================================================================== */
+/* Request mapper: OpenAI ➞ Gemini                                     */
+/* ================================================================== */
+export async function mapRequest(body: any) {
+  const parts: Part[] = [];
+
+  /* ---- convert messages & vision --------------------------------- */
+  for (const m of body.messages) {
+    if (Array.isArray(m.content)) {
+      for (const item of m.content) {
+        if (item.type === 'image_url') {
+          parts.push({ inlineData: await fetchAndEncode(item.image_url.url) });
+        } else if (item.type === 'text') {
+          parts.push({ text: item.text });
+        }
+      }
+    } else {
+      parts.push({ text: m.content });
+    }
+  }
+
+  /* ---- base generationConfig ------------------------------------- */
+  const generationConfig: Record<string, unknown> = {
+    temperature: body.temperature,
+    maxOutputTokens: body.max_tokens,
+    topP: body.top_p,
+    ...(body.generationConfig ?? {}), // copy anything ST already merged
+  };
+if (body.include_reasoning === true) {
+  generationConfig.enable_thoughts = true;        // ← current flag
+  generationConfig.thinking_budget ??= 2048;      // optional limit
+}
+
+  /* ---- auto-enable reasoning & 1 M context ----------------------- */
+  if (body.include_reasoning === true && generationConfig.thinking !== true) {
+    generationConfig.thinking = true;
+    generationConfig.thinking_budget ??= 2048;
+  }
+  generationConfig.maxInputTokens ??= 1_000_000; // lift context cap
+
+  const geminiReq = {
+    contents: [{ role: 'user', parts }],
+    generationConfig,
+    stream: body.stream,
+  };
+
+  /* ---- Tool / function mapping ----------------------------------- */
+  const tools = new ToolRegistry({} as any);
+
+  if (body.functions?.length) {
+    const reg = tools as any;
+    body.functions.forEach((fn: any) =>
+      reg.registerTool(
+        fn.name,
+        {
+          title: fn.name,
+          description: fn.description ?? '',
+          inputSchema: z.object(fn.parameters?.properties ?? {}),
+        },
+        async (args: unknown) => callLocalFunction(fn.name, args),
+      ),
+    );
+  }
+
+  return { geminiReq, tools };
+}
+
+/* ================================================================== */
+/* Non-stream response: Gemini ➞ OpenAI                                */
+/* ================================================================== */
+export function mapResponse(gResp: any) {
+  const usage = gResp.usageMetadata ?? {};
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: 'gemini-2.5-pro-latest',
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant', content: gResp.text },
+        finish_reason: 'stop',
+      },
+    ],
+    usage: {
+      prompt_tokens: usage.promptTokens ?? 0,
+      completion_tokens: usage.candidatesTokens ?? 0,
+      total_tokens: usage.totalTokens ?? 0,
+    },
+  };
+}
+
+/* ================================================================== */
+/* Stream chunk mapper: Gemini ➞ OpenAI                                */
+/* ================================================================== */
+
+export function mapStreamChunk(chunk: any) {
+  const part = chunk?.candidates?.[0]?.content?.parts?.[0] ?? {};
+  const delta: any = { role: 'assistant' };
+
+  if (part.thought === true) {
+    delta.content = `<think>${part.text ?? ''}`;  // ST renders grey bubble
+  } else if (typeof part.text === 'string') {
+    delta.content = part.text;
+  }
+  return { choices: [ { delta, index: 0 } ] };
+}
+
+

src/remoteimage.ts

@@ -0,0 +1,9 @@
+import { fetch } from 'undici';     // Node ≥18 has global fetch; otherwise add undici
+
+export async function fetchAndEncode(url: string) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to fetch image: ${url}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  const mimeType = res.headers.get('content-type') || 'image/png';
+  return { mimeType, data: buf.toString('base64') };
+}

src/server.ts

@@ -0,0 +1,97 @@
+import http from 'http';
+import { sendChat, sendChatStream } from './chatwrapper';
+import { mapRequest, mapResponse, mapStreamChunk } from './mapper';
+
+/* ── basic config ─────────────────────────────────────────────────── */
+const PORT = Number(process.env.PORT ?? 11434);
+
+/* ── CORS helper ──────────────────────────────────────────────────── */
+function allowCors(res: http.ServerResponse) {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Headers', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+}
+
+/* ── JSON body helper ─────────────────────────────────────────────── */
+function readJSON(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+): Promise<any | null> {
+  return new Promise((resolve) => {
+    let data = '';
+    req.on('data', (c) => (data += c));
+    req.on('end', () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch {
+        res.writeHead(400).end(); // malformed JSON
+        resolve(null);
+      }
+    });
+  });
+}
+
+/* ── server ───────────────────────────────────────────────────────── */
+http
+  .createServer(async (req, res) => {
+    allowCors(res);
+
+    /* -------- pre-flight ---------- */
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204).end();
+      return;
+    }
+
+    /* -------- /v1/models ---------- */
+    if (req.url === '/v1/models') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          data: [
+            {
+              id: 'gemini-2.5-pro-latest',
+              object: 'model',
+              owned_by: 'google',
+            },
+          ],
+        }),
+      );
+      return;
+    }
+
+    /* ---- /v1/chat/completions ---- */
+    if (req.url === '/v1/chat/completions' && req.method === 'POST') {
+      const body = await readJSON(req, res);
+      if (!body) return;
+
+      try {
+        const { geminiReq, tools } = await mapRequest(body);
+
+        if (body.stream) {
+          res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+          });
+
+          for await (const chunk of sendChatStream({ ...geminiReq, tools })) {
+            res.write(`data: ${JSON.stringify(mapStreamChunk(chunk))}\n\n`);
+          }
+          res.end('data: [DONE]\n\n');
+        } else {
+          const gResp = await sendChat({ ...geminiReq, tools });
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(mapResponse(gResp)));
+        }
+      } catch (err: any) {
+        console.error('Proxy error ➜', err);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: err.message } }));
+      }
+      return;
+    }
+
+    /* ---- anything else ---------- */
+    res.writeHead(404).end();
+  })
+  .listen(PORT, () => console.log(`OpenAI proxy on :${PORT}`));

tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    /* ---- target & module ---- */
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+
+    /* ---- quality-of-life ---- */
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+
+    /* ---- output dir ---- */
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}