@khanglvm/llm-router 1.3.1 → 2.0.0-beta.0

package/src/node/web-console-ui/rate-limit-utils.js

@@ -0,0 +1,144 @@
+export const RATE_LIMIT_ALL_MODELS_SELECTOR = "all";
+export const RATE_LIMIT_WINDOW_OPTIONS = ["second", "minute", "hour", "day", "week", "month"];
+
+function normalizePositiveInteger(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+export function normalizeRateLimitWindowUnit(value, fallback = "") {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (RATE_LIMIT_WINDOW_OPTIONS.includes(normalized)) return normalized;
+  return fallback;
+}
+
+export function pluralizeRateLimitWindowUnit(unit, windowValue = 1) {
+  const normalized = String(unit || "").trim().toLowerCase().replace(/s$/, "");
+  if (!normalized) return "windows";
+  return Number(windowValue) === 1 ? normalized : `${normalized}s`;
+}
+
+export function normalizeRateLimitModelSelectors(values = []) {
+  const normalized = [];
+  const seen = new Set();
+
+  for (const value of (Array.isArray(values) ? values : [values])) {
+    const trimmed = String(value || "").trim();
+    if (!trimmed) continue;
+    if (trimmed.toLowerCase() === RATE_LIMIT_ALL_MODELS_SELECTOR) {
+      return [RATE_LIMIT_ALL_MODELS_SELECTOR];
+    }
+    if (seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    normalized.push(trimmed);
+  }
+
+  return normalized;
+}
+
+export function buildAutoRateLimitBucketId({ requests, windowValue, windowUnit }) {
+  const normalizedRequests = normalizePositiveInteger(requests, 0);
+  const normalizedWindowValue = normalizePositiveInteger(windowValue, 0);
+  const normalizedWindowUnit = normalizeRateLimitWindowUnit(windowUnit, "");
+  if (!normalizedRequests || !normalizedWindowValue || !normalizedWindowUnit) return "";
+  return `${normalizedRequests}-req-per-${normalizedWindowValue}-${pluralizeRateLimitWindowUnit(normalizedWindowUnit, normalizedWindowValue)}`;
+}
+
+export function formatRateLimitBucketCap(bucket = {}) {
+  const requests = normalizePositiveInteger(bucket?.requests ?? bucket?.limit, 0);
+  const windowValue = normalizePositiveInteger(bucket?.window?.size ?? bucket?.window?.value ?? bucket?.windowValue, 0);
+  const windowUnit = normalizeRateLimitWindowUnit(bucket?.window?.unit ?? bucket?.windowUnit, "");
+  if (!requests || !windowValue || !windowUnit) return "Unconfigured";
+  return `${requests}/${windowValue} ${pluralizeRateLimitWindowUnit(windowUnit, windowValue)}`;
+}
+
+export function validateRateLimitDraftRows(rows = [], {
+  knownModelIds = [],
+  requireAtLeastOne = true
+} = {}) {
+  const normalizedRows = Array.isArray(rows) ? rows : [];
+  if (requireAtLeastOne && normalizedRows.length === 0) {
+    return "Add at least one rate-limit entity.";
+  }
+
+  const knownModels = new Set((knownModelIds || []).map((modelId) => String(modelId || "").trim()).filter(Boolean));
+  const seenBucketIds = new Set();
+
+  for (const row of normalizedRows) {
+    const models = normalizeRateLimitModelSelectors(row?.models || []);
+    if (knownModels.size > 0 && models.some((modelId) => modelId !== RATE_LIMIT_ALL_MODELS_SELECTOR && !knownModels.has(modelId))) {
+      return "Rate-limit model selectors must match the provider model ids.";
+    }
+
+    const requests = normalizePositiveInteger(row?.requests, 0);
+    if (!requests) {
+      return "Rate-limit requests must be a positive integer.";
+    }
+
+    const windowValue = normalizePositiveInteger(row?.windowValue, 0);
+    if (!windowValue) {
+      return "Rate-limit window size must be a positive integer.";
+    }
+
+    const windowUnit = normalizeRateLimitWindowUnit(row?.windowUnit, "");
+    if (!windowUnit) {
+      return "Rate-limit window unit is invalid.";
+    }
+
+    const bucketId = buildAutoRateLimitBucketId({ requests, windowValue, windowUnit });
+    if (seenBucketIds.has(bucketId)) {
+      return "Duplicate rate-limit entities are not allowed.";
+    }
+    seenBucketIds.add(bucketId);
+  }
+
+  return "";
+}
+
+export function buildRateLimitBucketsFromDraftRows(rows = [], {
+  existingBucketsBySourceId = new Map(),
+  fallbackRequests = 60,
+  fallbackWindowValue = 1,
+  fallbackWindowUnit = "minute"
+} = {}) {
+  return (Array.isArray(rows) ? rows : []).map((row, index) => {
+    const sourceId = String(row?.sourceId || "").trim();
+    const existingBucket = sourceId && existingBucketsBySourceId instanceof Map && existingBucketsBySourceId.has(sourceId)
+      ? structuredClone(existingBucketsBySourceId.get(sourceId))
+      : {};
+    const requests = normalizePositiveInteger(
+      row?.requests,
+      normalizePositiveInteger(existingBucket?.requests ?? existingBucket?.limit, fallbackRequests)
+    );
+    const windowValue = normalizePositiveInteger(
+      row?.windowValue,
+      normalizePositiveInteger(existingBucket?.window?.size ?? existingBucket?.window?.value, fallbackWindowValue)
+    );
+    const windowUnit = normalizeRateLimitWindowUnit(
+      row?.windowUnit,
+      normalizeRateLimitWindowUnit(existingBucket?.window?.unit, fallbackWindowUnit) || fallbackWindowUnit
+    );
+    const models = normalizeRateLimitModelSelectors(row?.models || []);
+    const effectiveModels = models.length > 0 ? models : [RATE_LIMIT_ALL_MODELS_SELECTOR];
+
+    const bucket = {
+      ...existingBucket,
+      id: buildAutoRateLimitBucketId({ requests, windowValue, windowUnit }) || `rate-limit-${index + 1}`,
+      models: effectiveModels,
+      requests,
+      window: {
+        ...(existingBucket?.window && typeof existingBucket.window === "object" && !Array.isArray(existingBucket.window) ? existingBucket.window : {}),
+        size: windowValue,
+        unit: windowUnit
+      }
+    };
+
+    delete bucket.name;
+    delete bucket.limit;
+    if (bucket.window && typeof bucket.window === "object") {
+      delete bucket.window.value;
+    }
+
+    return bucket;
+  });
+}

package/src/node/web-console-ui/select-search-utils.js

@@ -0,0 +1,36 @@
+function normalizeSelectSearchText(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+export function hasSelectSearchQuery(value) {
+  return normalizeSelectSearchText(value).length > 0;
+}
+
+export function getSelectSearchKey(event) {
+  const key = String(event?.key || "");
+  if (!key || key.length !== 1) return "";
+  if (event?.ctrlKey || event?.metaKey || event?.altKey) return "";
+  return key.trim() ? key : "";
+}
+
+export function optionMatchesSelectQuery(option = {}, query = "") {
+  const normalizedQuery = normalizeSelectSearchText(query);
+  if (!normalizedQuery) return true;
+
+  const haystack = [
+    option?.label,
+    option?.value,
+    option?.hint,
+    option?.textValue,
+    option?.searchText
+  ]
+    .map((entry) => String(entry || "").toLowerCase())
+    .join(" ");
+
+  return haystack.includes(normalizedQuery);
+}
+
+export function filterSelectOptions(options = [], query = "") {
+  const normalizedOptions = Array.isArray(options) ? options : [];
+  return normalizedOptions.filter((option) => optionMatchesSelectQuery(option, query));
+}

package/src/runtime/codex-request-transformer.js

@@ -27,12 +27,14 @@ export function transformRequestForCodex(body) {
     ? { ...body }
     : {};
 
-  const instructions = typeof transformed.instructions === 'string'
-    ? transformed.instructions.trim()
-    : '';
   const reasoning = normalizeReasoningConfig(transformed.reasoning, transformed.reasoning_effort);
   const include = normalizeIncludeList(transformed.include, reasoning);
-  const input = resolveResponseInput(transformed);
+  const resolvedInput = resolveResponseInput(transformed);
+  const extractedGuidance = extractLeadingInstructionMessages(resolvedInput);
+  const instructions = joinInstructionText(
+    typeof transformed.instructions === 'string' ? transformed.instructions.trim() : '',
+    extractedGuidance.instructions
+  );
   const tools = Array.isArray(transformed.tools)
     ? transformed.tools.map(normalizeToolDefinitionForResponses).filter(Boolean)
     : [];
@@ -40,7 +42,7 @@ export function transformRequestForCodex(body) {
   const output = {
     model: transformed.model,
     instructions: instructions || DEFAULT_CODEX_INSTRUCTIONS,
-    input,
+    input: extractedGuidance.input,
     tools,
     tool_choice: normalizeToolChoiceForResponses(transformed.tool_choice),
     parallel_tool_calls: Boolean(transformed.parallel_tool_calls),
@@ -68,6 +70,13 @@ function hasUsableInput(input) {
   return Array.isArray(input) && input.length > 0;
 }
 
+function joinInstructionText(...parts) {
+  return parts
+    .map((value) => (typeof value === 'string' ? value.trim() : ''))
+    .filter(Boolean)
+    .join('\n\n');
+}
+
 function resolveResponseInput(transformed) {
   if (hasUsableInput(transformed.input)) return transformed.input;
   if (typeof transformed.input === 'string' && transformed.input.trim()) {
@@ -83,6 +92,38 @@ function resolveResponseInput(transformed) {
   return [];
 }
 
+function isInstructionMessageItem(item) {
+  if (!item || typeof item !== 'object') return false;
+  if (item.type !== 'message') return false;
+  const role = normalizeMessageRole(item.role);
+  return role === 'system' || role === 'developer';
+}
+
+function extractLeadingInstructionMessages(input) {
+  if (!Array.isArray(input) || input.length === 0) {
+    return {
+      instructions: '',
+      input: []
+    };
+  }
+
+  const instructions = [];
+  let index = 0;
+
+  while (index < input.length) {
+    const item = input[index];
+    if (!isInstructionMessageItem(item)) break;
+    const text = normalizeMessageContentToText(item.content);
+    if (text) instructions.push(text);
+    index += 1;
+  }
+
+  return {
+    instructions: joinInstructionText(...instructions),
+    input: index > 0 ? input.slice(index) : input
+  };
+}
+
 function normalizeIncludeList(rawInclude, reasoning) {
   const include = Array.isArray(rawInclude)
     ? rawInclude.map((value) => String(value || '').trim()).filter(Boolean)

package/src/runtime/codex-response-transformer.js

@@ -133,6 +133,49 @@ function ensureAssistantRoleChunk(state, chunks) {
   chunks.push(makeOpenAIChunk(state, { role: 'assistant' }, null));
 }
 
+function commonPrefixLength(left, right) {
+  const leftText = typeof left === 'string' ? left : '';
+  const rightText = typeof right === 'string' ? right : '';
+  const limit = Math.min(leftText.length, rightText.length);
+  let index = 0;
+
+  while (index < limit && leftText[index] === rightText[index]) {
+    index += 1;
+  }
+
+  return index;
+}
+
+function getMissingSuffix(emittedText, finalText) {
+  const emitted = typeof emittedText === 'string' ? emittedText : '';
+  const finalValue = typeof finalText === 'string' ? finalText : '';
+
+  if (!finalValue) return '';
+  if (!emitted) return finalValue;
+  if (finalValue.startsWith(emitted)) {
+    return finalValue.slice(emitted.length);
+  }
+  if (emitted.startsWith(finalValue)) {
+    return '';
+  }
+
+  const prefixLength = commonPrefixLength(emitted, finalValue);
+  if (prefixLength <= 0) return '';
+  return finalValue.slice(prefixLength);
+}
+
+function parseStreamBlock(block) {
+  const normalized = String(block || '').trim();
+  if (!normalized) return null;
+  if (!normalized.includes('data:') && !normalized.includes('event:')) {
+    return {
+      eventType: '',
+      data: normalized
+    };
+  }
+  return parseSseBlock(normalized);
+}
+
 function parseSseBlock(block) {
   let eventType = '';
   const dataLines = [];
@@ -185,7 +228,7 @@ export function extractCodexFinalResponseFromText(rawText) {
 
   for (const block of blocks) {
     if (!block || !block.trim()) continue;
-    const parsedBlock = parseSseBlock(block);
+    const parsedBlock = parseStreamBlock(block);
     if (!parsedBlock.data || parsedBlock.data === '[DONE]') continue;
 
     let payload;
@@ -241,12 +284,114 @@ function updateStateFromResponse(state, response, fallbackModel) {
   }
 }
 
+function extractAssistantOutputText(item) {
+  if (!item || item.type !== 'message' || item.role !== 'assistant' || !Array.isArray(item.content)) {
+    return '';
+  }
+
+  const textParts = [];
+  for (const contentPart of item.content) {
+    if (!contentPart || typeof contentPart !== 'object') continue;
+    if (contentPart.type === 'output_text' && typeof contentPart.text === 'string') {
+      textParts.push(contentPart.text);
+      continue;
+    }
+    if (contentPart.type === 'refusal' && typeof contentPart.refusal === 'string') {
+      textParts.push(contentPart.refusal);
+    }
+  }
+
+  return textParts.join('');
+}
+
+function emitFallbackTextChunk(state, item, chunks) {
+  const text = extractAssistantOutputText(item);
+  if (!text) return;
+
+  const itemId = typeof item?.id === 'string' ? item.id.trim() : '';
+  const missingText = itemId
+    ? getMissingSuffix(state.textOutputByItemId.get(itemId) || '', text)
+    : (state.hasTextOutput ? '' : text);
+  if (!missingText) return;
+
+  ensureAssistantRoleChunk(state, chunks);
+  chunks.push(makeOpenAIChunk(state, { content: missingText }, null));
+  if (itemId) {
+    state.textOutputItemIds.add(itemId);
+    state.textOutputByItemId.set(itemId, `${state.textOutputByItemId.get(itemId) || ''}${missingText}`);
+  }
+  state.hasTextOutput = true;
+}
+
+function emitFallbackToolCallChunks(state, item, outputIndex, chunks) {
+  if (!item || item.type !== 'function_call') return;
+
+  ensureAssistantRoleChunk(state, chunks);
+  state.hasToolCalls = true;
+
+  const toolIndex = resolveToolIndex(state, {
+    output_index: outputIndex,
+    item_id: typeof item.id === 'string' && item.id.trim() ? item.id.trim() : undefined
+  });
+
+  if (!state.toolCallStartSentByIndex.has(toolIndex)) {
+    chunks.push(makeOpenAIChunk(state, {
+      tool_calls: [
+        {
+          index: toolIndex,
+          id: String(item.call_id || item.id || `call_${toolIndex}`),
+          type: 'function',
+          function: {
+            name: String(item.name || 'tool'),
+            arguments: ''
+          }
+        }
+      ]
+    }, null));
+    state.toolCallStartSentByIndex.add(toolIndex);
+  }
+
+  const argumentsText = typeof item.arguments === 'string' ? item.arguments : '';
+  const missingArguments = getMissingSuffix(state.toolCallArgumentsByIndex.get(toolIndex) || '', argumentsText);
+  if (missingArguments) {
+    chunks.push(makeOpenAIChunk(state, {
+      tool_calls: [
+        {
+          index: toolIndex,
+          function: {
+            arguments: missingArguments
+          }
+        }
+      ]
+    }, null));
+    state.toolCallArgumentsSeenByIndex.add(toolIndex);
+    state.toolCallArgumentsByIndex.set(toolIndex, `${state.toolCallArgumentsByIndex.get(toolIndex) || ''}${missingArguments}`);
+  }
+}
+
+function emitResponseOutputFallbacks(state, response, chunks) {
+  const outputItems = Array.isArray(response?.output) ? response.output : [];
+  for (let index = 0; index < outputItems.length; index += 1) {
+    const item = outputItems[index];
+    if (!item || typeof item !== 'object') continue;
+
+    if (item.type === 'message' && item.role === 'assistant') {
+      emitFallbackTextChunk(state, item, chunks);
+      continue;
+    }
+
+    if (item.type === 'function_call') {
+      emitFallbackToolCallChunks(state, item, index, chunks);
+    }
+  }
+}
+
 function eventToOpenAIChunks(event, state, { fallbackModel = 'unknown' } = {}) {
   if (!event || typeof event !== 'object') return [];
   const type = String(event.type || '').trim();
   const chunks = [];
 
-  if (type === 'response.created' || type === 'response.in_progress' || type === 'response.output_item.done') {
+  if (type === 'response.created' || type === 'response.in_progress') {
     updateStateFromResponse(state, event.response, fallbackModel);
     return chunks;
   }
@@ -259,6 +404,7 @@ function eventToOpenAIChunks(event, state, { fallbackModel = 'unknown' } = {}) {
       ensureAssistantRoleChunk(state, chunks);
       const toolIndex = resolveToolIndex(state, event);
       state.hasToolCalls = true;
+      state.toolCallStartSentByIndex.add(toolIndex);
       chunks.push(makeOpenAIChunk(state, {
         tool_calls: [
           {
@@ -280,34 +426,85 @@ function eventToOpenAIChunks(event, state, { fallbackModel = 'unknown' } = {}) {
     return chunks;
   }
 
+  if (type === 'response.reasoning_summary_text.delta') {
+    ensureAssistantRoleChunk(state, chunks);
+    chunks.push(makeOpenAIChunk(state, { reasoning_content: String(event.delta || '') }, null));
+    return chunks;
+  }
+
+  if (type === 'response.reasoning_summary_text.done') {
+    if (typeof event.text === 'string' && event.text) {
+      ensureAssistantRoleChunk(state, chunks);
+      chunks.push(makeOpenAIChunk(state, { reasoning_content: event.text }, null));
+    }
+    return chunks;
+  }
+
   if (type === 'response.output_text.delta') {
+    const deltaText = String(event.delta || '');
+    if (!deltaText) return chunks;
     ensureAssistantRoleChunk(state, chunks);
     if (typeof event.item_id === 'string' && event.item_id.trim()) {
-      state.textDeltaItemIds.add(event.item_id.trim());
+      const itemId = event.item_id.trim();
+      state.textOutputItemIds.add(itemId);
+      state.textOutputByItemId.set(itemId, `${state.textOutputByItemId.get(itemId) || ''}${deltaText}`);
     }
-    chunks.push(makeOpenAIChunk(state, { content: String(event.delta || '') }, null));
+    state.hasTextOutput = true;
+    chunks.push(makeOpenAIChunk(state, { content: deltaText }, null));
     return chunks;
   }
 
   if (type === 'response.output_text.done') {
     const itemId = typeof event.item_id === 'string' ? event.item_id.trim() : '';
-    if (itemId && !state.textDeltaItemIds.has(itemId) && typeof event.text === 'string' && event.text) {
+    const finalText = typeof event.text === 'string' ? event.text : '';
+    const missingText = itemId
+      ? getMissingSuffix(state.textOutputByItemId.get(itemId) || '', finalText)
+      : (state.hasTextOutput ? '' : finalText);
+    if (missingText) {
       ensureAssistantRoleChunk(state, chunks);
-      chunks.push(makeOpenAIChunk(state, { content: event.text }, null));
+      chunks.push(makeOpenAIChunk(state, { content: missingText }, null));
+      if (itemId) {
+        state.textOutputItemIds.add(itemId);
+        state.textOutputByItemId.set(itemId, `${state.textOutputByItemId.get(itemId) || ''}${missingText}`);
+      }
+      state.hasTextOutput = true;
     }
     return chunks;
   }
 
+  if (type === 'response.content_part.done') {
+    const itemId = typeof event.item_id === 'string' ? event.item_id.trim() : '';
+    const finalText = event.part?.type === 'output_text' && typeof event.part?.text === 'string'
+      ? event.part.text
+      : '';
+    const missingText = itemId
+      ? getMissingSuffix(state.textOutputByItemId.get(itemId) || '', finalText)
+      : (state.hasTextOutput ? '' : finalText);
+    if (!missingText) return chunks;
+    ensureAssistantRoleChunk(state, chunks);
+    chunks.push(makeOpenAIChunk(state, { content: missingText }, null));
+    if (itemId) {
+      state.textOutputItemIds.add(itemId);
+      state.textOutputByItemId.set(itemId, `${state.textOutputByItemId.get(itemId) || ''}${missingText}`);
+    }
+    state.hasTextOutput = true;
+    return chunks;
+  }
+
   if (type === 'response.function_call_arguments.delta') {
+    const deltaArguments = String(event.delta || '');
+    if (!deltaArguments) return chunks;
     ensureAssistantRoleChunk(state, chunks);
     const toolIndex = resolveToolIndex(state, event);
     state.hasToolCalls = true;
+    state.toolCallArgumentsSeenByIndex.add(toolIndex);
+    state.toolCallArgumentsByIndex.set(toolIndex, `${state.toolCallArgumentsByIndex.get(toolIndex) || ''}${deltaArguments}`);
     chunks.push(makeOpenAIChunk(state, {
       tool_calls: [
         {
           index: toolIndex,
           function: {
-            arguments: String(event.delta || '')
+            arguments: deltaArguments
           }
         }
       ]
@@ -316,15 +513,20 @@ function eventToOpenAIChunks(event, state, { fallbackModel = 'unknown' } = {}) {
   }
 
   if (type === 'response.function_call_arguments.done') {
-    ensureAssistantRoleChunk(state, chunks);
     const toolIndex = resolveToolIndex(state, event);
+    const finalArguments = String(event.arguments || '');
+    const missingArguments = getMissingSuffix(state.toolCallArgumentsByIndex.get(toolIndex) || '', finalArguments);
+    if (!missingArguments) return chunks;
+    ensureAssistantRoleChunk(state, chunks);
     state.hasToolCalls = true;
+    state.toolCallArgumentsSeenByIndex.add(toolIndex);
+    state.toolCallArgumentsByIndex.set(toolIndex, `${state.toolCallArgumentsByIndex.get(toolIndex) || ''}${missingArguments}`);
     chunks.push(makeOpenAIChunk(state, {
       tool_calls: [
         {
           index: toolIndex,
           function: {
-            arguments: String(event.arguments || '')
+            arguments: missingArguments
           }
         }
       ]
@@ -332,8 +534,26 @@ function eventToOpenAIChunks(event, state, { fallbackModel = 'unknown' } = {}) {
     return chunks;
   }
 
-  if (type === 'response.completed' || type === 'response.failed') {
+  if (type === 'response.output_item.done') {
     updateStateFromResponse(state, event.response, fallbackModel);
+    const item = event.item;
+    if (!item || typeof item !== 'object') return chunks;
+
+    if (item.type === 'message' && item.role === 'assistant') {
+      emitFallbackTextChunk(state, item, chunks);
+      return chunks;
+    }
+
+    if (item.type === 'function_call') {
+      emitFallbackToolCallChunks(state, item, Number.isFinite(event.output_index) ? Number(event.output_index) : 0, chunks);
+    }
+
+    return chunks;
+  }
+
+  if (type === 'response.completed' || type === 'response.failed' || type === 'response.incomplete') {
+    updateStateFromResponse(state, event.response, fallbackModel);
+    emitResponseOutputFallbacks(state, event.response, chunks);
     ensureAssistantRoleChunk(state, chunks);
     const responseUsage = toOpenAIUsage(event.response?.usage);
     const hasResponseToolCalls = Array.isArray(event.response?.output)
@@ -370,11 +590,43 @@ export function handleCodexStreamToOpenAI(response, { fallbackModel = 'unknown'
     toolCallByOutputIndex: new Map(),
     toolCallByItemId: new Map(),
     nextToolCallIndex: 0,
-    textDeltaItemIds: new Set()
+    toolCallStartSentByIndex: new Set(),
+    toolCallArgumentsSeenByIndex: new Set(),
+    toolCallArgumentsByIndex: new Map(),
+    textOutputItemIds: new Set(),
+    textOutputByItemId: new Map(),
+    hasTextOutput: false
   };
 
   let buffer = '';
 
+  function processBlock(block, controller) {
+    if (!block || !block.trim()) return;
+
+    const parsedBlock = parseStreamBlock(block);
+    if (!parsedBlock.data) return;
+
+    if (parsedBlock.data === '[DONE]') {
+      if (!state.doneSent) {
+        state.doneSent = true;
+        controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+      }
+      return;
+    }
+
+    let payload;
+    try {
+      payload = JSON.parse(parsedBlock.data);
+    } catch {
+      return;
+    }
+
+    const chunks = eventToOpenAIChunks(payload, state, { fallbackModel });
+    for (const translated of chunks) {
+      controller.enqueue(encoder.encode(serializeOpenAIChunk(translated)));
+    }
+  }
+
   const transformStream = new TransformStream({
     transform(chunk, controller) {
       buffer += decoder.decode(chunk, { stream: true }).replace(/\r\n/g, '\n');
@@ -383,34 +635,15 @@ export function handleCodexStreamToOpenAI(response, { fallbackModel = 'unknown'
       while ((boundaryIndex = buffer.indexOf('\n\n')) >= 0) {
         const block = buffer.slice(0, boundaryIndex);
         buffer = buffer.slice(boundaryIndex + 2);
-        if (!block.trim()) continue;
-
-        const parsedBlock = parseSseBlock(block);
-        if (!parsedBlock.data) continue;
-
-        if (parsedBlock.data === '[DONE]') {
-          if (!state.doneSent) {
-            state.doneSent = true;
-            controller.enqueue(encoder.encode('data: [DONE]\n\n'));
-          }
-          continue;
-        }
-
-        let payload;
-        try {
-          payload = JSON.parse(parsedBlock.data);
-        } catch {
-          continue;
-        }
-
-        const chunks = eventToOpenAIChunks(payload, state, { fallbackModel });
-        for (const translated of chunks) {
-          controller.enqueue(encoder.encode(serializeOpenAIChunk(translated)));
-        }
+        processBlock(block, controller);
       }
     },
 
     flush(controller) {
+      const remainder = buffer.trim();
+      if (remainder) {
+        processBlock(remainder, controller);
+      }
       if (state.doneSent) return;
       if (!state.roleSent) {
         controller.enqueue(encoder.encode(serializeOpenAIChunk(makeOpenAIChunk(state, { role: 'assistant' }, null))));