jbai-cli 1.9.2 → 2.1.0

package/bin/jbai-proxy.js

@@ -13,6 +13,7 @@
  *   /openai/v1/*       → Grazie OpenAI endpoint   (explicit)
  *   /anthropic/v1/*    → Grazie Anthropic endpoint (explicit)
  *   /google/v1/*       → Grazie Google endpoint    (explicit)
+ *   /grazie-openai/v1/* → OpenAI-compatible adapter over Grazie native Chat API
  *
  *   /v1/chat/completions → OpenAI   (auto-detect)
  *   /v1/completions      → OpenAI   (auto-detect)
@@ -45,6 +46,7 @@ const LOG_FILE = path.join(config.CONFIG_DIR, 'proxy.log');
 // ---------------------------------------------------------------------------
 let cachedToken = null;
 let tokenMtime = 0;
+let refreshInFlight = null;
 
 function getToken() {
   try {
@@ -59,6 +61,28 @@ function getToken() {
   return cachedToken;
 }
 
+// Auto-refresh: returns a valid token or throws
+async function getValidToken() {
+  let token = getToken();
+  if (!token) return null;
+  if (!config.isTokenExpiringSoon(token)) return token;
+
+  // Coalesce concurrent refresh attempts into a single API call
+  if (!refreshInFlight) {
+    refreshInFlight = config.refreshToken()
+      .then((t) => { cachedToken = t; tokenMtime = 0; return t; })
+      .finally(() => { refreshInFlight = null; });
+  }
+
+  try {
+    return await refreshInFlight;
+  } catch {
+    // Refresh failed — return current token if not fully expired yet
+    if (!config.isTokenExpired(token)) return token;
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Route resolution
 // ---------------------------------------------------------------------------
@@ -68,22 +92,45 @@ function resolveRoute(method, urlPath) {
 
   // Explicit provider prefix routes
   if (urlPath.startsWith('/openai/')) {
-    // Intercept /openai/v1/models → return synthetic list (Grazie doesn't list codex models)
+    // Intercept /openai/v1/models → return only OpenAI + Codex models
     if (urlPath === '/openai/v1/models') {
-      return { target: null, provider: 'models' };
+      return { target: null, provider: 'openai-models' };
     }
     const rest = urlPath.slice('/openai'.length); // keeps /v1/...
     return { target: endpoints.openai.replace(/\/v1$/, '') + rest, provider: 'openai' };
   }
   if (urlPath.startsWith('/anthropic/')) {
+    // Intercept /anthropic/v1/models → return only Claude models
+    if (urlPath === '/anthropic/v1/models') {
+      return { target: null, provider: 'anthropic-models' };
+    }
     const rest = urlPath.slice('/anthropic'.length);
     return { target: endpoints.anthropic.replace(/\/v1$/, '') + rest, provider: 'anthropic' };
   }
   if (urlPath.startsWith('/google/')) {
+    // Intercept /google/v1/models or /google/models → return only Gemini models
+    // (Gemini SDK may append /v1/models or just /models depending on version)
+    if (urlPath === '/google/v1/models' || urlPath === '/google/models') {
+      return { target: null, provider: 'google-models' };
+    }
     const rest = urlPath.slice('/google'.length);
     return { target: endpoints.google + rest, provider: 'google' };
   }
 
+  // OpenAI-compatible adapter over Grazie native chat API
+  if (urlPath.startsWith('/grazie-openai/')) {
+    if (urlPath === '/grazie-openai/v1/models') {
+      return { target: null, provider: 'grazie-openai-models' };
+    }
+    if (urlPath === '/grazie-openai/v1/chat/completions') {
+      return { target: null, provider: 'grazie-openai-chat' };
+    }
+    if (urlPath === '/grazie-openai/v1/responses') {
+      return { target: null, provider: 'grazie-openai-responses' };
+    }
+    return { target: null, provider: 'grazie-openai-unknown' };
+  }
+
   // Auto-detect routes based on standard SDK paths
   // Anthropic SDK always calls /v1/messages
   if (urlPath.startsWith('/v1/messages')) {
@@ -133,6 +180,932 @@ function buildModelsResponse() {
   return { object: 'list', data: models };
 }
 
+function buildOpenAIModelsResponse() {
+  const now = Math.floor(Date.now() / 1000);
+  const seen = new Set();
+  const models = [];
+
+  for (const m of config.MODELS.openai.available) {
+    models.push({ id: m, object: 'model', created: now, owned_by: 'openai' });
+    seen.add(m);
+  }
+  for (const m of config.MODELS.codex.available) {
+    if (!seen.has(m)) {
+      models.push({ id: m, object: 'model', created: now, owned_by: 'openai' });
+    }
+  }
+
+  return { object: 'list', data: models };
+}
+
+function buildAnthropicModelsResponse() {
+  const now = Math.floor(Date.now() / 1000);
+  const models = config.MODELS.claude.available.map(m => ({
+    id: m, object: 'model', created: now, owned_by: 'anthropic'
+  }));
+  return { object: 'list', data: models };
+}
+
+function buildGoogleModelsResponse() {
+  const now = Math.floor(Date.now() / 1000);
+  const models = config.MODELS.gemini.available.map(m => ({
+    id: m, object: 'model', created: now, owned_by: 'google'
+  }));
+  return { object: 'list', data: models };
+}
+
+// ---------------------------------------------------------------------------
+// Grazie profiles → OpenAI models adapter
+// ---------------------------------------------------------------------------
+
+let profilesCache = { tokenHash: null, fetchedAt: 0, profiles: null };
+
+function safeJsonParse(buf) {
+  try {
+    return JSON.parse(buf.toString('utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function tokenHash(token) {
+  // Cheap, non-cryptographic hash for caching isolation
+  let h = 0;
+  for (let i = 0; i < token.length; i++) h = (h * 31 + token.charCodeAt(i)) | 0;
+  return String(h);
+}
+
+function fetchProfiles(jwt, endpoints, ttlMs = 60_000) {
+  const now = Date.now();
+  const th = tokenHash(jwt);
+  if (profilesCache.profiles && profilesCache.tokenHash === th && (now - profilesCache.fetchedAt) < ttlMs) {
+    return Promise.resolve(profilesCache.profiles);
+  }
+
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoints.profiles);
+    const req = https.request({
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname + url.search,
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Grazie-Authenticate-JWT': jwt,
+        'Grazie-Agent': JSON.stringify({ name: 'jbai-proxy', version: '1.0' }),
+      },
+    }, (r) => {
+      const chunks = [];
+      r.on('data', (c) => chunks.push(c));
+      r.on('end', () => {
+        const body = Buffer.concat(chunks);
+        if (r.statusCode !== 200) {
+          reject(new Error(`Profiles fetch failed (HTTP ${r.statusCode})`));
+          return;
+        }
+        const parsed = safeJsonParse(body);
+        const profiles = Array.isArray(parsed) ? parsed : (parsed && Array.isArray(parsed.profiles) ? parsed.profiles : null);
+        if (!profiles) {
+          reject(new Error('Profiles fetch failed (unexpected response shape)'));
+          return;
+        }
+        profilesCache = { tokenHash: th, fetchedAt: now, profiles };
+        resolve(profiles);
+      });
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function buildGrazieOpenAIModelsResponse(profiles) {
+  const now = Math.floor(Date.now() / 1000);
+  const data = profiles
+    .filter((p) => p && p.id && !p.deprecated)
+    .map((p) => ({
+      id: p.id,
+      object: 'model',
+      created: now,
+      owned_by: p.provider || 'grazie',
+    }));
+  return { object: 'list', data };
+}
+
+function extractTextContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const item of content) {
+      if (!item || typeof item !== 'object') continue;
+      if (typeof item.text === 'string') parts.push(item.text);
+      else if ((item.type === 'text' || item.type === 'input_text' || item.type === 'output_text') && typeof item.text === 'string') parts.push(item.text);
+    }
+    return parts.join('\n');
+  }
+  return '';
+}
+
+function toOpenAiMessagesFromResponsesInput(input) {
+  // Minimal converter for OpenAI Responses API "input" shapes.
+  // Supports:
+  // - string
+  // - [{ role, content: string | [{type:"input_text",text}] }]
+  if (typeof input === 'string') {
+    return [{ role: 'user', content: input }];
+  }
+  if (!Array.isArray(input)) return [];
+
+  const out = [];
+  for (const item of input) {
+    if (!item || typeof item !== 'object') continue;
+    if (typeof item.role !== 'string') continue;
+    const role = item.role;
+    if (!['system', 'user', 'assistant', 'tool'].includes(role)) continue;
+    // OpenAI Responses uses content parts like {type:"input_text", text:"..."}
+    const content = extractTextContent(item.content);
+    out.push({ role, content });
+  }
+  return out;
+}
+
+function toGrazieMessages(openAiMessages) {
+  const out = [];
+  for (const m of (openAiMessages || [])) {
+    const role = m && m.role;
+
+    // Tool result messages: OpenAI role:"tool" → Grazie "tool_message"
+    if (role === 'tool') {
+      out.push({
+        type: 'tool_message',
+        id: m.tool_call_id || '',
+        toolName: m.name || '',
+        result: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+      });
+      continue;
+    }
+
+    // Assistant with tool_calls → emit assistant_message_tool for each call
+    if (role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
+      // If there's also text content, emit it as assistant_message_text first
+      const text = extractTextContent(m.content);
+      if (text) {
+        out.push({ type: 'assistant_message_text', content: text });
+      }
+      for (const tc of m.tool_calls) {
+        const fn = tc.function || {};
+        out.push({
+          type: 'assistant_message_tool',
+          id: tc.id || '',
+          toolName: fn.name || '',
+          content: fn.arguments || '',
+        });
+      }
+      continue;
+    }
+
+    let type;
+    if (role === 'system') type = 'system_message';
+    else if (role === 'user') type = 'user_message';
+    else if (role === 'assistant') type = 'assistant_message_text';
+    else continue;
+
+    const content = extractTextContent(m.content);
+    out.push({ type, content });
+  }
+  return out;
+}
+
+function toGrazieParameters(openAiBody) {
+  const data = [];
+  const add = (paramType, fqdn, value) => {
+    data.push({ type: paramType, fqdn, value });
+  };
+
+  if (openAiBody && typeof openAiBody.temperature === 'number') {
+    add('double', 'llm.parameters.temperature', openAiBody.temperature);
+  }
+  if (openAiBody && typeof openAiBody.top_p === 'number') {
+    add('double', 'llm.parameters.top-p', openAiBody.top_p);
+  }
+  const maxTokens = openAiBody && (openAiBody.max_output_tokens ?? openAiBody.max_tokens ?? openAiBody.max_completion_tokens);
+  if (Number.isInteger(maxTokens)) {
+    add('int', 'llm.parameters.length', maxTokens);
+  }
+
+  // Stop sequences — Grazie uses 'stop-token' (string per token)
+  if (openAiBody && openAiBody.stop) {
+    const stops = Array.isArray(openAiBody.stop) ? openAiBody.stop : [openAiBody.stop];
+    // Send each stop token individually (Grazie accepts repeated keys)
+    for (const s of stops) {
+      add('string', 'llm.parameters.stop-token', s);
+    }
+  }
+
+  // Tools — unwrap from OpenAI {type:"function",function:{...}} to Grazie {name,description,parameters:{schema}}
+  if (openAiBody && openAiBody.tools && openAiBody.tools.length) {
+    const grazieTools = toGrazieTools(openAiBody.tools);
+    add('json', 'llm.parameters.tools', grazieTools);
+  }
+
+  // Tool choice — Grazie uses separate attribute keys, not a single JSON object
+  if (openAiBody && openAiBody.tool_choice !== undefined) {
+    const tc = openAiBody.tool_choice;
+    if (tc === 'auto') {
+      add('bool', 'llm.parameters.tool-choice-auto', true);
+    } else if (tc === 'none') {
+      add('bool', 'llm.parameters.tool-choice-none', true);
+    } else if (tc === 'required') {
+      add('bool', 'llm.parameters.tool-choice-required', true);
+    } else if (typeof tc === 'object' && tc.type === 'function' && tc.function) {
+      add('string', 'llm.parameters.tool-choice-named', tc.function.name);
+    }
+  }
+
+  // Parallel tool calls
+  if (openAiBody && openAiBody.parallel_tool_calls !== undefined) {
+    add('bool', 'llm.parameters.parallel-tool-calls', !!openAiBody.parallel_tool_calls);
+  }
+
+  return data.length ? { data } : null;
+}
+
+function toGrazieTools(openAiTools) {
+  if (!Array.isArray(openAiTools) || openAiTools.length === 0) return null;
+  return openAiTools.map((t) => {
+    const fn = (t && t.type === 'function' && t.function) ? t.function : t;
+    return {
+      name: fn && fn.name,
+      description: (fn && fn.description) || undefined,
+      parameters: (fn && fn.parameters) || undefined,
+    };
+  }).filter(t => t && typeof t.name === 'string' && t.name.length > 0);
+}
+
+function extractGrazieToolCallEvent(evt) {
+  if (!evt || typeof evt !== 'object') return null;
+
+  const tcIdFromEvt = typeof evt.id === 'string'
+    ? evt.id
+    : (typeof evt.tool_call_id === 'string' ? evt.tool_call_id : (typeof evt.toolCallId === 'string' ? evt.toolCallId : ''));
+
+  const pti = Number.isInteger(evt.parallelToolIndex)
+    ? evt.parallelToolIndex
+    : (Number.isInteger(evt.parallel_tool_index) ? evt.parallel_tool_index : null);
+
+  const tcName = typeof evt.name === 'string'
+    ? evt.name
+    : (typeof evt.toolName === 'string' ? evt.toolName : (evt.function && typeof evt.function.name === 'string' ? evt.function.name : ''));
+
+  const tcChunk = (typeof evt.content === 'string')
+    ? evt.content
+    : (typeof evt.arguments === 'string')
+      ? evt.arguments
+      : (evt.function && typeof evt.function.arguments === 'string')
+        ? evt.function.arguments
+        : (typeof evt.args === 'string' ? evt.args : '');
+
+  const looksLikeTool =
+    (typeof evt.type === 'string' && /(tool|function)_?call/i.test(evt.type)) ||
+    !!tcIdFromEvt ||
+    pti !== null ||
+    !!tcName ||
+    !!tcChunk;
+
+  if (!looksLikeTool) return null;
+  return { tcIdFromEvt, pti, tcName, tcChunk };
+}
+
+function openAiSseWrite(res, obj) {
+  res.write(`data: ${JSON.stringify(obj)}\n\n`);
+}
+
+function openAiSseDone(res) {
+  res.write('data: [DONE]\n\n');
+}
+
+function handleGrazieOpenAIChat({ req, res, jwt, endpoints, urlPath, startTime, requestBody }) {
+  let parsed;
+  try {
+    parsed = JSON.parse(requestBody.toString('utf-8'));
+  } catch {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: { message: 'Invalid JSON body', type: 'invalid_request_error' } }));
+    return;
+  }
+
+  const model = parsed.model;
+  if (!model || typeof model !== 'string') {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: { message: 'Missing required field: model', type: 'invalid_request_error' } }));
+    return;
+  }
+
+  const messages = toGrazieMessages(parsed.messages);
+  const payload = {
+    profile: model,
+    chat: { messages },
+  };
+
+  // Some Grazie backends expect tools on the chat payload (not only in parameters).
+  const chatTools = toGrazieTools(parsed.tools);
+  if (chatTools && chatTools.length) {
+    payload.chat.tools = chatTools;
+  }
+
+  const parameters = toGrazieParameters(parsed);
+  if (parameters) payload.parameters = parameters;
+
+  const stream = parsed.stream !== false;
+  const chatUrl = new URL(endpoints.base);
+  const chatPaths = [
+    '/user/v5/llm/chat/stream/v9',
+    '/user/v5/llm/chat/stream/v8',
+  ];
+  const payloadStr = JSON.stringify(payload);
+
+  // Gap 4: retry helper — wraps the upstream call; retries once on 401 after token refresh
+  function doUpstream(currentJwt, isRetry, chatPathIndex = 0) {
+    const chatPath = chatPaths[Math.min(chatPathIndex, chatPaths.length - 1)];
+    const upstreamReq = https.request({
+      hostname: chatUrl.hostname,
+      port: 443,
+      path: chatPath,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'Grazie-Authenticate-JWT': currentJwt,
+        'Grazie-Agent': JSON.stringify({ name: 'jbai-proxy', version: '1.0' }),
+      },
+    }, (upstreamRes) => {
+      // Gap 4: on 401, refresh token and retry once
+      if (upstreamRes.statusCode === 401 && !isRetry) {
+        upstreamRes.resume();
+        log(`[grazie-openai] POST ${urlPath} → 401 from upstream, refreshing token…`);
+        config.refreshToken()
+          .then((fresh) => {
+            cachedToken = fresh;
+            tokenMtime = 0;
+            doUpstream(fresh, true, chatPathIndex);
+          })
+          .catch(() => {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Grazie token expired. Run: jbai token set', type: 'authentication_error' } }));
+          });
+        return;
+      }
+
+      // Prefer v9, fall back to v8 if v9 is not available upstream.
+      if (upstreamRes.statusCode === 404 && chatPathIndex === 0 && chatPaths.length > 1) {
+        upstreamRes.resume();
+        log(`[grazie-openai] POST ${urlPath} → 404 on ${chatPath}, retrying with ${chatPaths[1]}…`);
+        doUpstream(currentJwt, isRetry, 1);
+        return;
+      }
+
+      if (upstreamRes.statusCode !== 200) {
+        const chunks = [];
+        upstreamRes.on('data', (c) => chunks.push(c));
+        upstreamRes.on('end', () => {
+          const msg = Buffer.concat(chunks).toString('utf-8');
+          res.writeHead(upstreamRes.statusCode || 502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { message: msg || `Upstream error (${upstreamRes.statusCode})`, type: 'upstream_error' } }));
+        });
+        return;
+      }
+
+      if (stream) {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream; charset=utf-8',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+        });
+      }
+
+      const id = `chatcmpl_${Math.random().toString(16).slice(2)}`;
+      const created = Math.floor(Date.now() / 1000);
+      let full = '';
+      let sentRole = false;
+      // Tool call state: support both v9 (id/name/content) and legacy parallelToolIndex.
+      // seenTools maps a stable key → { index, id, name, args }
+      const seenTools = new Map();
+      const toolOrder = [];
+      let nextToolIndex = 0;
+      let finishReason = 'stop';
+
+      let buf = '';
+      upstreamRes.on('data', (chunk) => {
+        buf += chunk.toString('utf-8');
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const dataStr = line.slice(6).trim();
+          if (!dataStr) continue;
+          if (dataStr === 'end') continue;
+          let evt;
+          try {
+            evt = JSON.parse(dataStr);
+          } catch {
+            continue;
+          }
+
+          if (!evt || typeof evt !== 'object') continue;
+
+          // Emit initial role delta before first content (OpenAI convention)
+          if (!sentRole && stream) {
+            openAiSseWrite(res, {
+              id,
+              object: 'chat.completion.chunk',
+              created,
+              model,
+              choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+            });
+            sentRole = true;
+          }
+
+          // Error events
+          if (evt.type === 'Error') {
+            const errMsg = evt.content || evt.message || 'Unknown upstream error';
+            if (stream) {
+              openAiSseWrite(res, {
+                id,
+                object: 'chat.completion.chunk',
+                created,
+                model,
+                choices: [{ index: 0, delta: { content: `[Error: ${errMsg}]` }, finish_reason: null }],
+              });
+            } else {
+              full += `[Error: ${errMsg}]`;
+            }
+            log(`[grazie-openai] Upstream error event: ${errMsg}`);
+            continue;
+          }
+
+          // Content chunks
+          if (evt.type === 'Content' && typeof evt.content === 'string') {
+            if (stream) {
+              openAiSseWrite(res, {
+                id,
+                object: 'chat.completion.chunk',
+                created,
+                model,
+                choices: [{ index: 0, delta: { content: evt.content }, finish_reason: null }],
+              });
+            } else {
+              full += evt.content;
+            }
+            continue;
+          }
+
+          // Tool call events: support v9 ToolCall plus older/variant shapes.
+          const tce = extractGrazieToolCallEvent(evt);
+          if (tce) {
+            const { tcIdFromEvt, pti, tcName, tcChunk } = tce;
+            const key = tcIdFromEvt
+              ? `id:${tcIdFromEvt}`
+              : (pti !== null ? `pti:${pti}` : null);
+            if (!key) {
+              // If it looks like a tool call but lacks identifiers, log for discovery.
+              if (!evt.type) {
+                log(`[grazie-openai] Tool-like SSE event missing id/index: ${JSON.stringify(evt).slice(0, 200)}`);
+              }
+              continue;
+            }
+
+            let entry = seenTools.get(key);
+            const isFirst = !entry;
+
+            if (isFirst) {
+              const index = (pti !== null && pti >= 0) ? pti : nextToolIndex++;
+              const idVal = tcIdFromEvt || `call_${Math.random().toString(16).slice(2)}`;
+              entry = { index, id: idVal, name: tcName || '', args: tcChunk || '' };
+              seenTools.set(key, entry);
+              toolOrder.push(key);
+              finishReason = 'tool_calls';
+
+              if (stream) {
+                openAiSseWrite(res, {
+                  id,
+                  object: 'chat.completion.chunk',
+                  created,
+                  model,
+                  choices: [{
+                    index: 0,
+                    delta: {
+                      tool_calls: [{
+                        index: entry.index,
+                        id: entry.id,
+                        type: 'function',
+                        function: {
+                          ...(entry.name ? { name: entry.name } : {}),
+                          ...(tcChunk ? { arguments: tcChunk } : {}),
+                        },
+                      }],
+                    },
+                    finish_reason: null,
+                  }],
+                });
+              }
+            } else {
+              // Subsequent chunk: append name/arguments as they arrive
+              let nameDelta = '';
+              if (tcName && !entry.name) {
+                entry.name = tcName;
+                nameDelta = tcName;
+              }
+              if (tcChunk) entry.args += tcChunk;
+              finishReason = 'tool_calls';
+
+              if (stream && (nameDelta || tcChunk)) {
+                openAiSseWrite(res, {
+                  id,
+                  object: 'chat.completion.chunk',
+                  created,
+                  model,
+                  choices: [{
+                    index: 0,
+                    delta: {
+                      tool_calls: [{
+                        index: entry.index,
+                        ...(nameDelta ? { function: { name: nameDelta } } : {}),
+                        ...(tcChunk ? { function: { ...(nameDelta ? { name: nameDelta } : {}), arguments: tcChunk } } : {}),
+                      }],
+                    },
+                    finish_reason: null,
+                  }],
+                });
+              }
+            }
+            continue;
+          }
+
+          // FinishMetadata — map reason to OpenAI format
+          if (evt.type === 'FinishMetadata') {
+            const reason = evt.reason;
+            if (reason === 'tool_call' || reason === 'function_call') {
+              finishReason = 'tool_calls';
+            } else if (reason === 'length') {
+              finishReason = 'length';
+            }
+            // 'stop' is already the default
+            continue;
+          }
+
+          // Log unrecognized event types for discovery
+          if (evt.type && !['Content', 'FinishMetadata', 'Error', 'ToolCall', 'tool_call', 'QuotaMetadata', 'UnknownMetadata'].includes(evt.type)) {
+            log(`[grazie-openai] Unrecognized SSE event type: ${evt.type} — ${JSON.stringify(evt).slice(0, 200)}`);
+          }
+        }
+      });
+
+      upstreamRes.on('end', () => {
+        if (stream) {
+          openAiSseWrite(res, {
+            id,
+            object: 'chat.completion.chunk',
+            created,
+            model,
+            choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
+          });
+          openAiSseDone(res);
+          res.end();
+        } else {
+          const message = { role: 'assistant', content: full || null };
+          // Build tool_calls array from accumulated seenTools
+          if (toolOrder.length > 0) {
+            message.tool_calls = toolOrder
+              .map((k) => seenTools.get(k))
+              .filter(Boolean)
+              .map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: tc.args },
+              }));
+          }
+          res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Access-Control-Allow-Origin': '*',
+          });
+          res.end(JSON.stringify({
+            id,
+            object: 'chat.completion',
+            created,
+            model,
+            choices: [{ index: 0, message, finish_reason: finishReason }],
+          }));
+        }
+
+        log(`[grazie-openai] POST ${urlPath} → 200 (${Date.now() - startTime}ms)`);
+      });
+    });
+
+    upstreamReq.on('error', (e) => {
+      if (!res.headersSent) {
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: `Upstream request failed: ${e.message}`, type: 'upstream_error' } }));
+      }
+    });
+
+    upstreamReq.write(payloadStr);
+    upstreamReq.end();
+  }
+
+  doUpstream(jwt, false, 0);
+}
+
+function responsesSseWrite(res, obj) {
+  res.write(`data: ${JSON.stringify(obj)}\n\n`);
+}
+
+function responsesSseDone(res) {
+  res.write('data: [DONE]\n\n');
+}
+
+function handleGrazieOpenAIResponses({ req, res, jwt, endpoints, urlPath, startTime, requestBody }) {
+  let parsed;
+  try {
+    parsed = JSON.parse(requestBody.toString('utf-8'));
+  } catch {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: { message: 'Invalid JSON body', type: 'invalid_request_error' } }));
+    return;
+  }
+
+  const model = parsed.model;
+  if (!model || typeof model !== 'string') {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: { message: 'Missing required field: model', type: 'invalid_request_error' } }));
+    return;
+  }
+
+  // Responses API: map instructions + input/messages into OpenAI-like messages
+  const openAiMessages = [];
+  if (typeof parsed.instructions === 'string' && parsed.instructions.trim()) {
+    openAiMessages.push({ role: 'system', content: parsed.instructions });
+  }
+  if (parsed.messages) {
+    // Some clients still send chat-completions style "messages".
+    openAiMessages.push(...(Array.isArray(parsed.messages) ? parsed.messages : []));
+  } else if (parsed.input !== undefined) {
+    openAiMessages.push(...toOpenAiMessagesFromResponsesInput(parsed.input));
+  }
+
+  const messages = toGrazieMessages(openAiMessages);
+  const payload = {
+    profile: model,
+    chat: { messages },
+  };
+
+  const chatTools = toGrazieTools(parsed.tools);
+  if (chatTools && chatTools.length) {
+    payload.chat.tools = chatTools;
+  }
+
+  const parameters = toGrazieParameters(parsed);
+  if (parameters) payload.parameters = parameters;
+
+  const stream = parsed.stream === true;
+  const chatUrl = new URL(endpoints.base);
+  const chatPaths = [
+    '/user/v5/llm/chat/stream/v9',
+    '/user/v5/llm/chat/stream/v8',
+  ];
+  const payloadStr = JSON.stringify(payload);
+
+  function doUpstream(currentJwt, isRetry, chatPathIndex = 0) {
+    const chatPath = chatPaths[Math.min(chatPathIndex, chatPaths.length - 1)];
+    const upstreamReq = https.request({
+      hostname: chatUrl.hostname,
+      port: 443,
+      path: chatPath,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'Grazie-Authenticate-JWT': currentJwt,
+        'Grazie-Agent': JSON.stringify({ name: 'jbai-proxy', version: '1.0' }),
+      },
+    }, (upstreamRes) => {
+      if (upstreamRes.statusCode === 401 && !isRetry) {
+        upstreamRes.resume();
+        log(`[grazie-openai] POST ${urlPath} → 401 from upstream, refreshing token…`);
+        config.refreshToken()
+          .then((fresh) => {
+            cachedToken = fresh;
+            tokenMtime = 0;
+            doUpstream(fresh, true, chatPathIndex);
+          })
+          .catch(() => {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Grazie token expired. Run: jbai token set', type: 'authentication_error' } }));
+          });
+        return;
+      }
+
+      if (upstreamRes.statusCode === 404 && chatPathIndex === 0 && chatPaths.length > 1) {
+        upstreamRes.resume();
+        log(`[grazie-openai] POST ${urlPath} → 404 on ${chatPath}, retrying with ${chatPaths[1]}…`);
+        doUpstream(currentJwt, isRetry, 1);
+        return;
+      }
+
+      if (upstreamRes.statusCode !== 200) {
+        const chunks = [];
+        upstreamRes.on('data', (c) => chunks.push(c));
+        upstreamRes.on('end', () => {
+          const msg = Buffer.concat(chunks).toString('utf-8');
+          res.writeHead(upstreamRes.statusCode || 502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { message: msg || `Upstream error (${upstreamRes.statusCode})`, type: 'upstream_error' } }));
+        });
+        return;
+      }
+
+      const id = `resp_${Math.random().toString(16).slice(2)}`;
+      const createdAt = Math.floor(Date.now() / 1000);
+
+      let fullText = '';
+      const seenTools = new Map();
+      const toolOrder = [];
+      let nextToolIndex = 0;
+
+      const output = [];
+      const messageItemId = `msg_${Math.random().toString(16).slice(2)}`;
+      const messageOutputIndex = 0;
+      output.push({
+        id: messageItemId,
+        type: 'message',
+        role: 'assistant',
+        content: [{ type: 'output_text', text: '' }],
+      });
+
+      const responseObj = () => ({
+        id,
+        object: 'response',
+        created_at: createdAt,
+        model,
+        output,
+      });
+
+      if (stream) {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream; charset=utf-8',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+        });
+        responsesSseWrite(res, { type: 'response.created', response: responseObj() });
+        responsesSseWrite(res, {
+          type: 'response.output_item.added',
+          output_index: messageOutputIndex,
+          item: output[messageOutputIndex],
+        });
+        responsesSseWrite(res, {
+          type: 'response.content_part.added',
+          output_index: messageOutputIndex,
+          content_index: 0,
+          part: output[messageOutputIndex].content[0],
+        });
+      }
+
+      let buf = '';
+      upstreamRes.on('data', (chunk) => {
+        buf += chunk.toString('utf-8');
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const dataStr = line.slice(6).trim();
+          if (!dataStr) continue;
+          if (dataStr === 'end') continue;
+          let evt;
+          try {
+            evt = JSON.parse(dataStr);
+          } catch {
+            continue;
+          }
+          if (!evt || typeof evt !== 'object') continue;
+
+          if (evt.type === 'Error') {
+            const errMsg = evt.content || evt.message || 'Unknown upstream error';
+            if (stream) {
+              responsesSseWrite(res, { type: 'response.output_text.delta', output_index: messageOutputIndex, content_index: 0, delta: `\n[Error: ${errMsg}]` });
+            }
+            fullText += `\n[Error: ${errMsg}]`;
+            output[messageOutputIndex].content[0].text = fullText;
+            log(`[grazie-openai] Upstream error event: ${errMsg}`);
+            continue;
+          }
+
+          if (evt.type === 'Content' && typeof evt.content === 'string') {
+            fullText += evt.content;
+            output[messageOutputIndex].content[0].text = fullText;
+            if (stream) {
+              responsesSseWrite(res, { type: 'response.output_text.delta', output_index: messageOutputIndex, content_index: 0, delta: evt.content });
+            }
+            continue;
+          }
+
+          const tce = extractGrazieToolCallEvent(evt);
+          if (tce) {
+            const { tcIdFromEvt, pti, tcName, tcChunk } = tce;
+            const key = tcIdFromEvt
+              ? `id:${tcIdFromEvt}`
+              : (pti !== null ? `pti:${pti}` : null);
+            if (!key) {
+              if (!evt.type) {
+                log(`[grazie-openai] Tool-like SSE event missing id/index (responses): ${JSON.stringify(evt).slice(0, 200)}`);
+              }
+              continue;
+            }
+
+            let entry = seenTools.get(key);
+            const isFirst = !entry;
+            if (isFirst) {
+              const index = (pti !== null && pti >= 0) ? pti : nextToolIndex++;
+              const callId = tcIdFromEvt || `call_${Math.random().toString(16).slice(2)}`;
+              entry = { index, id: callId, name: tcName || '', args: tcChunk || '' };
+              seenTools.set(key, entry);
+              toolOrder.push(key);
+
+              const outputIndex = output.length;
+              entry.outputIndex = outputIndex;
+              output.push({
+                id: entry.id,
+                type: 'function_call',
+                call_id: entry.id,
+                name: entry.name,
+                arguments: entry.args,
+              });
+
+              if (stream) {
+                responsesSseWrite(res, { type: 'response.output_item.added', output_index: outputIndex, item: output[outputIndex] });
+                if (tcChunk) {
+                  responsesSseWrite(res, { type: 'response.function_call_arguments.delta', output_index: outputIndex, item_id: entry.id, delta: tcChunk });
+                }
+              }
+            } else {
+              let argsDelta = '';
+              if (tcName && !entry.name) {
+                entry.name = tcName;
+                const item = output[entry.outputIndex];
+                if (item) item.name = tcName;
+              }
+              if (tcChunk) {
+                entry.args += tcChunk;
+                argsDelta = tcChunk;
+                const item = output[entry.outputIndex];
+                if (item) item.arguments = entry.args;
+              }
+              if (stream && argsDelta) {
+                responsesSseWrite(res, { type: 'response.function_call_arguments.delta', output_index: entry.outputIndex, item_id: entry.id, delta: argsDelta });
+              }
+            }
+            continue;
+          }
+
+          // Log unrecognized event types for discovery (helps map tool calling variants)
+          if (evt.type && !['Content', 'Error', 'ToolCall', 'tool_call', 'FinishMetadata', 'QuotaMetadata', 'UnknownMetadata'].includes(evt.type)) {
+            log(`[grazie-openai] Unrecognized SSE event type (responses): ${evt.type} — ${JSON.stringify(evt).slice(0, 200)}`);
+          }
+        }
+      });
+
+      upstreamRes.on('end', () => {
+        const finalResponse = responseObj();
+
+        if (stream) {
+          responsesSseWrite(res, { type: 'response.completed', response: finalResponse });
+          responsesSseDone(res);
+          res.end();
+        } else {
+          res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Access-Control-Allow-Origin': '*',
+          });
+          res.end(JSON.stringify(finalResponse));
+        }
+
+        log(`[grazie-openai] POST ${urlPath} → 200 (${Date.now() - startTime}ms)`);
+      });
+    });
+
+    upstreamReq.on('error', (e) => {
+      if (!res.headersSent) {
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: `Upstream request failed: ${e.message}`, type: 'upstream_error' } }));
+      }
+    });
+
+    upstreamReq.write(payloadStr);
+    upstreamReq.end();
+  }
+
+  doUpstream(jwt, false, 0);
+}
+
 // Codex CLI model picker response (matches chatgpt.com/backend-api/codex/models format)
 function buildCodexModelsResponse() {
   const descriptions = {
@@ -209,6 +1182,7 @@ function proxy(req, res) {
           openai: 'http://localhost:' + (res.socket?.localPort || DEFAULT_PORT) + '/openai/v1  OR  /v1/chat/completions',
           anthropic: 'http://localhost:' + (res.socket?.localPort || DEFAULT_PORT) + '/anthropic/v1  OR  /v1/messages',
           google: 'http://localhost:' + (res.socket?.localPort || DEFAULT_PORT) + '/google/v1',
+          grazie_openai: 'http://localhost:' + (res.socket?.localPort || DEFAULT_PORT) + '/grazie-openai/v1',
         }
       };
       res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -221,35 +1195,93 @@ function proxy(req, res) {
     return;
   }
 
-  // Synthetic models endpoint
-  if (route.provider === 'models') {
+  // Synthetic models endpoints (provider-specific and catch-all)
+  if (route.provider === 'models' || route.provider === 'openai-models' || route.provider === 'anthropic-models' || route.provider === 'google-models') {
+    let body;
+    switch (route.provider) {
+      case 'openai-models':    body = buildOpenAIModelsResponse(); break;
+      case 'anthropic-models': body = buildAnthropicModelsResponse(); break;
+      case 'google-models':    body = buildGoogleModelsResponse(); break;
+      default:                 body = buildModelsResponse(); break;
+    }
     res.writeHead(200, {
       'Content-Type': 'application/json',
       'Access-Control-Allow-Origin': '*',
     });
-    res.end(JSON.stringify(buildModelsResponse()));
-    log(`[models] GET /v1/models → 200 (${Date.now() - startTime}ms)`);
-    return;
-  }
-
-  // Get token
-  const token = getToken();
-  if (!token) {
-    res.writeHead(401, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: { message: 'No Grazie token found. Run: jbai token set', type: 'authentication_error' } }));
-    return;
-  }
-
-  if (config.isTokenExpired(token)) {
-    res.writeHead(401, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: { message: 'Grazie token expired. Run: jbai token set', type: 'authentication_error' } }));
+    res.end(JSON.stringify(body));
+    log(`[${route.provider}] GET ${urlPath} → 200 (${Date.now() - startTime}ms)`);
     return;
   }
 
-  // Read request body
+  // Read request body, then authenticate + forward
   const chunks = [];
   req.on('data', (chunk) => chunks.push(chunk));
-  req.on('end', () => {
+  req.on('end', async () => {
+    // --- Token (with auto-refresh) ---
+    let token;
+    try {
+      token = await getValidToken();
+    } catch {
+      token = null;
+    }
+
+    if (!token) {
+      const msg = getToken() ? 'Grazie token expired. Run: jbai token set' : 'No Grazie token found. Run: jbai token set';
+      res.writeHead(401, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: msg, type: 'authentication_error' } }));
+      return;
+    }
+
+    // Grazie → OpenAI adapter endpoints
+    if (route.provider === 'grazie-openai-models') {
+      try {
+        const profiles = await fetchProfiles(token, config.getEndpoints());
+        const body = buildGrazieOpenAIModelsResponse(profiles);
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        });
+        res.end(JSON.stringify(body));
+        log(`[grazie-openai-models] GET ${urlPath} → 200 (${Date.now() - startTime}ms)`);
+      } catch (e) {
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: e.message || 'Failed to fetch profiles', type: 'upstream_error' } }));
+      }
+      return;
+    }
+
+    if (route.provider === 'grazie-openai-chat') {
+      handleGrazieOpenAIChat({
+        req,
+        res,
+        jwt: token,
+        endpoints: config.getEndpoints(),
+        urlPath,
+        startTime,
+        requestBody: Buffer.concat(chunks),
+      });
+      return;
+    }
+
+    if (route.provider === 'grazie-openai-responses') {
+      handleGrazieOpenAIResponses({
+        req,
+        res,
+        jwt: token,
+        endpoints: config.getEndpoints(),
+        urlPath,
+        startTime,
+        requestBody: Buffer.concat(chunks),
+      });
+      return;
+    }
+
+    if (route.provider === 'grazie-openai-unknown') {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: `Unknown grazie-openai route: ${urlPath}`, type: 'invalid_request_error' } }));
+      return;
+    }
+
     let body = Buffer.concat(chunks);
 
     // Rewrite model aliases so Grazie accepts the request
@@ -269,57 +1301,69 @@ function proxy(req, res) {
 
     const targetUrl = new URL(route.target + (query ? '?' + query : ''));
 
-    // Build forwarded headers - pass through everything except host/authorization
-    const fwdHeaders = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-      const lower = key.toLowerCase();
-      // Skip hop-by-hop and host headers
-      if (['host', 'connection', 'keep-alive', 'transfer-encoding', 'te', 'trailer', 'upgrade'].includes(lower)) continue;
-      // Skip authorization (we inject our own)
-      if (lower === 'authorization') continue;
-      fwdHeaders[key] = value;
-    }
+    // --- Forward helper (used for initial attempt + 401 retry) ---
+    function forward(jwt, isRetry) {
+      const fwdHeaders = {};
+      for (const [key, value] of Object.entries(req.headers)) {
+        const lower = key.toLowerCase();
+        if (['host', 'connection', 'keep-alive', 'transfer-encoding', 'te', 'trailer', 'upgrade'].includes(lower)) continue;
+        if (lower === 'authorization') continue;
+        fwdHeaders[key] = value;
+      }
+      fwdHeaders['Grazie-Authenticate-JWT'] = jwt;
+      if (body.length > 0) {
+        fwdHeaders['content-length'] = body.length;
+      }
 
-    // Inject Grazie auth
-    fwdHeaders['Grazie-Authenticate-JWT'] = token;
+      const proxyReq = https.request({
+        hostname: targetUrl.hostname,
+        port: 443,
+        path: targetUrl.pathname + targetUrl.search,
+        method: req.method,
+        headers: fwdHeaders,
+      }, (proxyRes) => {
+        // On 401 from Grazie, try refreshing the token once
+        if (proxyRes.statusCode === 401 && !isRetry) {
+          // Consume the error response before retrying
+          proxyRes.resume();
+          log(`[${route.provider}] ${req.method} ${urlPath} → 401 from upstream, refreshing token…`);
+          config.refreshToken()
+            .then((fresh) => {
+              cachedToken = fresh;
+              tokenMtime = 0;
+              forward(fresh, true);
+            })
+            .catch(() => {
+              res.writeHead(401, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: { message: 'Grazie token expired. Run: jbai token set', type: 'authentication_error' } }));
+            });
+          return;
+        }
 
-    // Ensure content-length is correct for the body we have
-    if (body.length > 0) {
-      fwdHeaders['content-length'] = body.length;
-    }
+        const resHeaders = { ...proxyRes.headers, 'Access-Control-Allow-Origin': '*' };
+        res.writeHead(proxyRes.statusCode, resHeaders);
+        proxyRes.pipe(res);
+        proxyRes.on('end', () => {
+          const elapsed = Date.now() - startTime;
+          log(`[${route.provider}] ${req.method} ${urlPath} → ${proxyRes.statusCode} (${elapsed}ms)`);
+        });
+      });
 
-    const proxyReq = https.request({
-      hostname: targetUrl.hostname,
-      port: 443,
-      path: targetUrl.pathname + targetUrl.search,
-      method: req.method,
-      headers: fwdHeaders,
-    }, (proxyRes) => {
-      // Forward status and headers
-      const resHeaders = { ...proxyRes.headers, 'Access-Control-Allow-Origin': '*' };
-      res.writeHead(proxyRes.statusCode, resHeaders);
-
-      // Stream response (supports SSE streaming)
-      proxyRes.pipe(res);
-
-      proxyRes.on('end', () => {
-        const elapsed = Date.now() - startTime;
-        log(`[${route.provider}] ${req.method} ${urlPath} → ${proxyRes.statusCode} (${elapsed}ms)`);
+      proxyReq.on('error', (err) => {
+        log(`[${route.provider}] ${req.method} ${urlPath} → ERROR: ${err.message}`);
+        if (!res.headersSent) {
+          res.writeHead(502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { message: `Proxy error: ${err.message}`, type: 'proxy_error' } }));
+        }
       });
-    });
 
-    proxyReq.on('error', (err) => {
-      log(`[${route.provider}] ${req.method} ${urlPath} → ERROR: ${err.message}`);
-      if (!res.headersSent) {
-        res.writeHead(502, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: { message: `Proxy error: ${err.message}`, type: 'proxy_error' } }));
+      if (body.length > 0) {
+        proxyReq.write(body);
       }
-    });
-
-    if (body.length > 0) {
-      proxyReq.write(body);
+      proxyReq.end();
     }
-    proxyReq.end();
+
+    forward(token, false);
   });
 }