claude-scionos 4.3.4 → 4.4.0

package/README.fr.md

@@ -78,7 +78,7 @@ npx claude-scionos --strategy aws --no-prompt -p "Résume ce dépôt"
 - `claude-gpt` : mappe les requêtes Claude vers la famille `claude-gpt`
   `claude-gpt-5.5 ==> claude-opus-4.7`, `claude-gpt-5.4 ==> claude-sonnet-4.6`, `claude-gpt-5.4-mini ==> claude-gpt-5.4-mini`
 - `claude-gpt-special` : sur `--service llm`, force toutes les requêtes vers `claude-gpt-5.4-sp`
-- `deepseek-v4-beta` : sur `--service llm`, mappe les requêtes Claude vers `deepseek-v4-pro` pour opus et `deepseek-v4-flash` pour sonnet ou haiku
+- `deepseek-v4-beta` : sur `--service llm`, mappe les requêtes Claude vers `claude-deepseek-v4-pro` pour opus ou sonnet et `claude-deepseek-v4-flash` pour haiku
 - `claude-qwen3.6-plus` : force toutes les requêtes vers `claude-qwen3.6-plus`
 - `claude-minimax-m2.7` : force toutes les requêtes vers `claude-minimax-m2.7`
 - `claude-glm-5.1` : force toutes les requêtes vers `claude-glm-5.1`

package/README.md

@@ -78,7 +78,7 @@ npx claude-scionos --strategy aws --no-prompt -p "Summarize this repo"
 - `claude-gpt`: map Claude requests to the `claude-gpt` family
   `claude-gpt-5.5 ==> claude-opus-4.7`, `claude-gpt-5.4 ==> claude-sonnet-4.6`, `claude-gpt-5.4-mini ==> claude-gpt-5.4-mini`
 - `claude-gpt-special`: on `--service llm`, force all requests to `claude-gpt-5.4-sp`
-- `deepseek-v4-beta`: on `--service llm`, map Claude requests to `deepseek-v4-pro` for opus and `deepseek-v4-flash` for sonnet or haiku
+- `deepseek-v4-beta`: on `--service llm`, map Claude requests to `claude-deepseek-v4-pro` for opus or sonnet and `claude-deepseek-v4-flash` for haiku
 - `claude-qwen3.6-plus`: force all requests to `claude-qwen3.6-plus`
 - `claude-minimax-m2.7`: force all requests to `claude-minimax-m2.7`
 - `claude-glm-5.1`: force all requests to `claude-glm-5.1`

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-scionos",
-    "version": "4.3.4",
+    "version": "4.4.0",
     "description": "RouterLab launcher, strategy proxy and secure token wrapper for Claude Code CLI",
     "type": "module",
     "main": "index.js",

package/src/proxy.js

@@ -1,368 +1,649 @@
 import http from 'node:http';
+import {Transform} from 'node:stream';
 import {BASE_URL, DEFAULT_ANTHROPIC_VERSION} from './routerlab.js';
-
-const HOP_BY_HOP_HEADERS = new Set([
-  'connection',
-  'content-length',
-  'content-encoding',
-  'host',
-  'keep-alive',
-  'proxy-authenticate',
-  'proxy-authorization',
-  'te',
-  'trailer',
-  'transfer-encoding',
-  'upgrade',
-]);
+
+const HOP_BY_HOP_HEADERS = new Set([
+  'connection',
+  'content-length',
+  'content-encoding',
+  'host',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+]);
 const PROXY_AUTH_HEADER = 'x-scionos-proxy-secret';
 const MESSAGES_PATH = '/v1/messages';
+const REASONING_CONTENT_BLOCK_TYPES = new Set(['thinking', 'redacted_thinking']);
+const REASONING_DELTA_TYPES = new Set(['thinking_delta', 'signature_delta']);
+
+function normalizeProxyHeaders(headers) {
+  const normalizedHeaders = {};
+
+  for (const [key, value] of Object.entries(headers ?? {})) {
+    if (value === undefined || HOP_BY_HOP_HEADERS.has(key.toLowerCase())) {
+      continue;
+    }
+
+    normalizedHeaders[key] = value;
+  }
+
+  return normalizedHeaders;
+}
+
+function buildProxyRequestOptions(url, method, upstreamHeaders, validToken, bodyLength, timeout) {
+  const headers = normalizeProxyHeaders(upstreamHeaders);
+  deleteHeader(headers, 'authorization');
+  deleteHeader(headers, PROXY_AUTH_HEADER);
+  deleteHeader(headers, 'accept-encoding');
+  headers['x-api-key'] = validToken;
+  headers['anthropic-version'] ??= DEFAULT_ANTHROPIC_VERSION;
+
+  if (bodyLength !== undefined) {
+    headers['Content-Length'] = String(bodyLength);
+  }
+
+  return {
+    hostname: url.hostname,
+    port: url.port || 443,
+    path: url.pathname + url.search,
+    method,
+    headers,
+    timeout,
+  };
+}
 
-function normalizeProxyHeaders(headers) {
-  const normalizedHeaders = {};
-
-  for (const [key, value] of Object.entries(headers ?? {})) {
-    if (value === undefined || HOP_BY_HOP_HEADERS.has(key.toLowerCase())) {
-      continue;
+function deleteHeader(headers, headerName) {
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === headerName.toLowerCase()) {
+      delete headers[key];
     }
-
-    normalizedHeaders[key] = value;
   }
-
-  return normalizedHeaders;
 }
 
-function buildProxyRequestOptions(url, method, upstreamHeaders, validToken, bodyLength, timeout) {
-  const headers = normalizeProxyHeaders(upstreamHeaders);
-  delete headers.authorization;
-  delete headers[PROXY_AUTH_HEADER];
-  headers['x-api-key'] = validToken;
-  headers['anthropic-version'] ??= DEFAULT_ANTHROPIC_VERSION;
+function isReasoningContentBlock(block) {
+  return REASONING_CONTENT_BLOCK_TYPES.has(block?.type);
+}
 
-  if (bodyLength !== undefined) {
-    headers['Content-Length'] = String(bodyLength);
+function sanitizeContentBlocks(content) {
+  if (!Array.isArray(content)) {
+    return {content, changed: false};
   }
 
+  const sanitized = content.filter((block) => !isReasoningContentBlock(block));
   return {
-    hostname: url.hostname,
-    port: url.port || 443,
-    path: url.pathname + url.search,
-    method,
-    headers,
-    timeout,
+    content: sanitized,
+    changed: sanitized.length !== content.length,
   };
 }
 
-function getPreferredClaudeGptModel(requestedModel = '') {
-  if (requestedModel.includes('haiku') || requestedModel.includes('mini')) {
-    return 'claude-gpt-5.4-mini';
+function sanitizeAnthropicCompatiblePayload(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return {payload, changed: false};
   }
 
-  if (requestedModel.includes('opus')) {
-    return 'claude-gpt-5.5';
+  let changed = false;
+  const sanitizedPayload = {...payload};
+
+  if (Array.isArray(payload.content)) {
+    const sanitizedContent = sanitizeContentBlocks(payload.content);
+    sanitizedPayload.content = sanitizedContent.content;
+    changed ||= sanitizedContent.changed;
   }
 
-  return 'claude-gpt-5.4';
-}
+  if (Array.isArray(payload.messages)) {
+    sanitizedPayload.messages = payload.messages.map((message) => {
+      if (!message || typeof message !== 'object') {
+        return message;
+      }
 
-function getPreferredClaudeModel(requestedModel = '') {
-  if (requestedModel.includes('haiku') || requestedModel.includes('mini')) {
-    return 'claude-haiku-4-5-20251001';
-  }
+      const sanitizedContent = sanitizeContentBlocks(message.content);
+      if (!sanitizedContent.changed) {
+        return message;
+      }
 
-  if (requestedModel.includes('opus')) {
-    return 'claude-opus-4-6';
+      changed = true;
+      return {
+        ...message,
+        content: sanitizedContent.content,
+      };
+    });
   }
 
-  return 'claude-sonnet-4-6';
+  return {payload: changed ? sanitizedPayload : payload, changed};
 }
-
+
+function getPreferredClaudeGptModel(requestedModel = '') {
+  if (requestedModel.includes('haiku') || requestedModel.includes('mini')) {
+    return 'claude-gpt-5.4-mini';
+  }
+
+  if (requestedModel.includes('opus')) {
+    return 'claude-gpt-5.5';
+  }
+
+  return 'claude-gpt-5.4';
+}
+
+function getPreferredClaudeModel(requestedModel = '') {
+  if (requestedModel.includes('haiku') || requestedModel.includes('mini')) {
+    return 'claude-haiku-4-5-20251001';
+  }
+
+  if (requestedModel.includes('opus')) {
+    return 'claude-opus-4-6';
+  }
+
+  return 'claude-sonnet-4-6';
+}
+
 function getPreferredDeepseekV4Model(requestedModel = '') {
-  if (requestedModel.includes('opus')) {
-    return 'deepseek-v4-pro';
+  if (requestedModel.includes('opus') || requestedModel.includes('sonnet')) {
+    return 'claude-deepseek-v4-pro';
   }
 
-  return 'deepseek-v4-flash';
-}
+  return 'claude-deepseek-v4-flash';
+}
+
+function resolveMappedModel(targetModel, requestedModel = '', availableModels = []) {
+  if (targetModel === 'claude') {
+    const preferredModel = getPreferredClaudeModel(requestedModel);
+    const availableClaudeModels = Array.isArray(availableModels)
+      ? availableModels.filter((model) => model.startsWith('claude-') && !model.startsWith('claude-gpt-'))
+      : [];
+
+    if (availableClaudeModels.length === 0) {
+      return preferredModel;
+    }
+
+    if (availableClaudeModels.includes(preferredModel)) {
+      return preferredModel;
+    }
+
+    return (
+      availableClaudeModels.find((model) => model === 'claude-sonnet-4-6')
+      ?? availableClaudeModels[0]
+      ?? preferredModel
+    );
+  }
+
+  if (targetModel === 'claude-gpt-special') {
+    return 'claude-gpt-5.4-sp';
+  }
+
+  if (targetModel === 'deepseek-v4-beta') {
+    const preferredModel = getPreferredDeepseekV4Model(requestedModel);
+    const availableDeepseekModels = Array.isArray(availableModels)
+      ? availableModels.filter((model) => model === 'claude-deepseek-v4-pro' || model === 'claude-deepseek-v4-flash')
+      : [];
+
+    if (availableDeepseekModels.length === 0) {
+      return preferredModel;
+    }
+
+    if (availableDeepseekModels.includes(preferredModel)) {
+      return preferredModel;
+    }
+
+    return (
+      availableDeepseekModels.find((model) => model === 'claude-deepseek-v4-flash')
+      ?? availableDeepseekModels[0]
+      ?? preferredModel
+    );
+  }
+
+  if (targetModel !== 'aws') {
+    if (targetModel !== 'claude-gpt') {
+      return targetModel;
+    }
+
+    const preferredModel = getPreferredClaudeGptModel(requestedModel);
+    const availableClaudeGptModels = Array.isArray(availableModels)
+      ? availableModels.filter((model) => model.startsWith('claude-gpt-'))
+      : [];
+
+    if (availableClaudeGptModels.length === 0) {
+      return preferredModel;
+    }
+
+    if (availableClaudeGptModels.includes(preferredModel)) {
+      return preferredModel;
+    }
+
+    return (
+      availableClaudeGptModels.find((model) => model === 'claude-gpt-5.4')
+      ?? availableClaudeGptModels[0]
+      ?? preferredModel
+    );
+  }
+
+  if (requestedModel.includes('haiku')) {
+    return 'aws-claude-haiku-4-5-20251001';
+  }
+
+  if (requestedModel.includes('opus')) {
+    return 'aws-claude-opus-4-6';
+  }
+
+  return 'aws-claude-sonnet-4-6';
+}
+
+function writeJsonError(res, statusCode, payload) {
+  if (res.headersSent) {
+    return;
+  }
+
+  res.writeHead(statusCode);
+  res.end(JSON.stringify(payload));
+}
+
+function getRequestPath(req) {
+  return new URL(req.url, 'http://127.0.0.1').pathname;
+}
+
+function isAuthorizedProxyRequest(req, proxySecret) {
+  if (!proxySecret) {
+    return true;
+  }
+
+  return req.headers[PROXY_AUTH_HEADER] === proxySecret;
+}
+
+function isAllowedProxyRoute(req) {
+  return req.method === 'POST' && getRequestPath(req) === MESSAGES_PATH;
+}
+
+async function handleMessageRequest(req, res, options) {
+  const {availableModels = [], baseUrl, debug, onDebug, onError, targetModel, validToken} = options;
+  const chunks = [];
+  const maxSize = 100 * 1024 * 1024;
+  let totalSize = 0;
+
+  req.on('data', (chunk) => {
+    totalSize += chunk.length;
+    if (totalSize > maxSize) {
+      writeJsonError(res, 413, {error: {message: 'Request too large'}});
+      req.destroy();
+      return;
+    }
+
+    chunks.push(chunk);
+  });
+
+  req.on('end', async () => {
+    try {
+      const bodyBuffer = Buffer.concat(chunks);
+      let bodyJson;
+
+      try {
+        bodyJson = JSON.parse(bodyBuffer.toString());
+      } catch {
+        bodyJson = null;
+      }
+
+      if (bodyJson?.model) {
+        const preferredModel = resolveMappedModel(targetModel, bodyJson.model);
+        const newModel = resolveMappedModel(targetModel, bodyJson.model, availableModels);
+        if (debug) {
+          onDebug(`[Proxy] Swapping model ${bodyJson.model} -> ${newModel}`);
+          if (preferredModel !== newModel) {
+            onDebug(`[Proxy] Fallback applied because ${preferredModel} is not available for this token`);
+          }
+        }
 
-function resolveMappedModel(targetModel, requestedModel = '', availableModels = []) {
-  if (targetModel === 'claude') {
-    const preferredModel = getPreferredClaudeModel(requestedModel);
-    const availableClaudeModels = Array.isArray(availableModels)
-      ? availableModels.filter((model) => model.startsWith('claude-') && !model.startsWith('claude-gpt-'))
-      : [];
+        bodyJson.model = newModel;
+      }
 
-    if (availableClaudeModels.length === 0) {
-      return preferredModel;
-    }
+      if (bodyJson) {
+        bodyJson = sanitizeAnthropicCompatiblePayload(bodyJson).payload;
+      }
 
-    if (availableClaudeModels.includes(preferredModel)) {
-      return preferredModel;
+      const payload = bodyJson ? JSON.stringify(bodyJson) : bodyBuffer;
+      await forwardRequest(req, res, {
+        baseUrl,
+        bodyLength: typeof payload === 'string' ? Buffer.byteLength(payload) : payload.length,
+        debug,
+        onDebug,
+        onError,
+        payload,
+        timeout: 120000,
+        validToken,
+      });
+    } catch (error) {
+      onError(`[Proxy Error] POST ${MESSAGES_PATH}: ${error.message}`);
+      writeJsonError(res, 500, {
+        error: {
+          message: 'Scionos Proxy Error',
+          details: error.message,
+        },
+      });
+    }
+  });
+}
+
+async function forwardRequest(req, res, options) {
+  const {baseUrl, bodyLength, debug, onDebug, onError, payload, timeout, validToken} = options;
+  const https = await import('node:https');
+  const url = new URL(`${baseUrl}${req.url}`);
+  const requestOptions = buildProxyRequestOptions(
+    url,
+    req.method,
+    req.headers,
+    validToken,
+    bodyLength,
+    timeout,
+  );
+
+  const proxyReq = https.request(requestOptions, (proxyRes) => {
+    if (debug) {
+      onDebug(`[Proxy] Upstream response status: ${proxyRes.statusCode}`);
     }
 
-    return (
-      availableClaudeModels.find((model) => model === 'claude-sonnet-4-6')
-      ?? availableClaudeModels[0]
-      ?? preferredModel
-    );
-  }
-
-  if (targetModel === 'claude-gpt-special') {
-    return 'claude-gpt-5.4-sp';
+    handleProxyResponse(proxyRes, res, {debug, onDebug, onError});
+  });
+
+  proxyReq.on('error', (error) => {
+    onError(`[Proxy Error] ${req.method} ${req.url}: ${error.message}`);
+    if (debug && error.code) {
+      onError(`[Proxy Error] Code: ${error.code}`);
+    }
+
+    writeJsonError(res, req.method === 'POST' && getRequestPath(req) === MESSAGES_PATH ? 500 : 502, {
+      error: {
+        message: req.method === 'POST' && getRequestPath(req) === MESSAGES_PATH
+          ? 'Proxy Error'
+          : 'Scionos Proxy Error: Failed to connect to upstream',
+        details: error.message,
+        ...(error.code ? {code: error.code} : {}),
+      },
+    });
+  });
+
+  proxyReq.on('timeout', () => {
+    onError('[Proxy] Request timeout');
+    proxyReq.destroy();
+    writeJsonError(res, 504, {error: {message: 'Gateway Timeout'}});
+  });
+
+  if (payload !== undefined) {
+    proxyReq.write(payload);
+    proxyReq.end();
+    if (debug) {
+      onDebug('[Proxy] Request sent to upstream');
+    }
+    return;
+  }
+
+  if (req.method === 'POST' || req.method === 'PUT') {
+    req.pipe(proxyReq);
+  } else {
+    proxyReq.end();
   }
+}
 
-  if (targetModel === 'deepseek-v4-beta') {
-    const preferredModel = getPreferredDeepseekV4Model(requestedModel);
-    const availableDeepseekModels = Array.isArray(availableModels)
-      ? availableModels.filter((model) => model === 'deepseek-v4-pro' || model === 'deepseek-v4-flash')
-      : [];
+function handleProxyResponse(proxyRes, res, options = {}) {
+  const contentType = String(proxyRes.headers['content-type'] ?? '');
+  const contentEncoding = String(proxyRes.headers['content-encoding'] ?? '');
 
-    if (availableDeepseekModels.length === 0) {
-      return preferredModel;
-    }
-
-    if (availableDeepseekModels.includes(preferredModel)) {
-      return preferredModel;
-    }
+  if (contentEncoding && contentEncoding !== 'identity') {
+    res.writeHead(proxyRes.statusCode, proxyRes.headers);
+    proxyRes.pipe(res);
+    return;
+  }
 
-    return (
-      availableDeepseekModels.find((model) => model === 'deepseek-v4-flash')
-      ?? availableDeepseekModels[0]
-      ?? preferredModel
-    );
+  if (contentType.includes('text/event-stream')) {
+    const headers = normalizeProxyHeaders(proxyRes.headers);
+    deleteHeader(headers, 'content-length');
+    deleteHeader(headers, 'content-encoding');
+    res.writeHead(proxyRes.statusCode, headers);
+    proxyRes.pipe(createAnthropicSseSanitizer(options)).pipe(res);
+    return;
   }
 
-  if (targetModel !== 'aws') {
-    if (targetModel !== 'claude-gpt') {
-      return targetModel;
-    }
+  if (!contentType.includes('application/json')) {
+    res.writeHead(proxyRes.statusCode, proxyRes.headers);
+    proxyRes.pipe(res);
+    return;
+  }
 
-    const preferredModel = getPreferredClaudeGptModel(requestedModel);
-    const availableClaudeGptModels = Array.isArray(availableModels)
-      ? availableModels.filter((model) => model.startsWith('claude-gpt-'))
-      : [];
+  const chunks = [];
+  proxyRes.on('data', (chunk) => chunks.push(chunk));
+  proxyRes.on('end', () => {
+    const bodyBuffer = Buffer.concat(chunks);
+    let bodyText = bodyBuffer.toString('utf8');
 
-    if (availableClaudeGptModels.length === 0) {
-      return preferredModel;
+    try {
+      const parsed = JSON.parse(bodyText);
+      const sanitized = sanitizeAnthropicCompatiblePayload(parsed);
+      if (sanitized.changed) {
+        bodyText = JSON.stringify(sanitized.payload);
+        if (options.debug) {
+          options.onDebug('[Proxy] Removed upstream reasoning content blocks from JSON response');
+        }
+      }
+    } catch {
+      bodyText = bodyBuffer.toString('utf8');
     }
 
-    if (availableClaudeGptModels.includes(preferredModel)) {
-      return preferredModel;
-    }
+    const headers = normalizeProxyHeaders(proxyRes.headers);
+    deleteHeader(headers, 'content-length');
+    deleteHeader(headers, 'content-encoding');
+    headers['content-length'] = String(Buffer.byteLength(bodyText));
+    res.writeHead(proxyRes.statusCode, headers);
+    res.end(bodyText);
+  });
 
-    return (
-      availableClaudeGptModels.find((model) => model === 'claude-gpt-5.4')
-      ?? availableClaudeGptModels[0]
-      ?? preferredModel
-    );
-  }
+  proxyRes.on('error', (error) => {
+    options.onError?.(`[Proxy Error] Upstream response read failed: ${error.message}`);
+    res.destroy(error);
+  });
+}
 
-  if (requestedModel.includes('haiku')) {
-    return 'aws-claude-haiku-4-5-20251001';
-  }
+function createAnthropicSseSanitizer(options = {}) {
+  const state = {
+    droppedIndexes: new Set(),
+    indexMap: new Map(),
+    loggedReasoningRemoval: false,
+    nextIndex: 0,
+  };
+  let pending = '';
+
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      pending += chunk.toString('utf8');
+      const events = pending.split(/\r?\n\r?\n/);
+      pending = events.pop() ?? '';
+
+      for (const eventText of events) {
+        const sanitized = sanitizeSseEvent(eventText, state, options);
+        if (sanitized) {
+          this.push(`${sanitized}\n\n`);
+        }
+      }
 
-  if (requestedModel.includes('opus')) {
-    return 'aws-claude-opus-4-6';
-  }
+      callback();
+    },
+    flush(callback) {
+      const sanitized = sanitizeSseEvent(pending, state, options);
+      if (sanitized) {
+        this.push(`${sanitized}\n\n`);
+      }
 
-  return 'aws-claude-sonnet-4-6';
+      callback();
+    },
+  });
 }
 
-function writeJsonError(res, statusCode, payload) {
-  if (res.headersSent) {
-    return;
+function sanitizeSseEvent(eventText, state, options = {}) {
+  if (!eventText.trim()) {
+    return '';
   }
 
-  res.writeHead(statusCode);
-  res.end(JSON.stringify(payload));
-}
+  const lines = eventText.split(/\r?\n/);
+  const dataLines = lines.filter((line) => line.startsWith('data:'));
 
-function getRequestPath(req) {
-  return new URL(req.url, 'http://127.0.0.1').pathname;
-}
+  if (dataLines.length === 0) {
+    return eventText;
+  }
 
-function isAuthorizedProxyRequest(req, proxySecret) {
-  if (!proxySecret) {
-    return true;
+  const data = dataLines.map((line) => line.slice(5).trimStart()).join('\n');
+  if (data === '[DONE]') {
+    return eventText;
   }
 
-  return req.headers[PROXY_AUTH_HEADER] === proxySecret;
-}
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return eventText;
+  }
 
-function isAllowedProxyRoute(req) {
-  return req.method === 'POST' && getRequestPath(req) === MESSAGES_PATH;
-}
+  const sanitized = sanitizeAnthropicStreamEvent(parsed, state);
+  if (!sanitized) {
+    if (options.debug && !state.loggedReasoningRemoval) {
+      options.onDebug('[Proxy] Removed upstream reasoning content block from stream response');
+      state.loggedReasoningRemoval = true;
+    }
+    return '';
+  }
 
-async function handleMessageRequest(req, res, options) {
-  const {availableModels = [], baseUrl, debug, onDebug, onError, targetModel, validToken} = options;
-  const chunks = [];
-  const maxSize = 100 * 1024 * 1024;
-  let totalSize = 0;
-
-  req.on('data', (chunk) => {
-    totalSize += chunk.length;
-    if (totalSize > maxSize) {
-      writeJsonError(res, 413, {error: {message: 'Request too large'}});
-      req.destroy();
-      return;
+  const outputLines = [];
+  let wroteData = false;
+  for (const line of lines) {
+    if (line.startsWith('data:')) {
+      if (!wroteData) {
+        outputLines.push(`data: ${JSON.stringify(sanitized)}`);
+        wroteData = true;
+      }
+      continue;
     }
 
-    chunks.push(chunk);
-  });
+    outputLines.push(line);
+  }
 
-  req.on('end', async () => {
-    try {
-      const bodyBuffer = Buffer.concat(chunks);
-      let bodyJson;
+  return outputLines.join('\n');
+}
 
-      try {
-        bodyJson = JSON.parse(bodyBuffer.toString());
-      } catch {
-        bodyJson = null;
-      }
+function sanitizeAnthropicStreamEvent(event, state) {
+  if (!event || typeof event !== 'object') {
+    return event;
+  }
 
-      if (bodyJson?.model) {
-        const preferredModel = resolveMappedModel(targetModel, bodyJson.model);
-        const newModel = resolveMappedModel(targetModel, bodyJson.model, availableModels);
-        if (debug) {
-          onDebug(`[Proxy] Swapping model ${bodyJson.model} -> ${newModel}`);
-          if (preferredModel !== newModel) {
-            onDebug(`[Proxy] Fallback applied because ${preferredModel} is not available for this token`);
-          }
-        }
+  if (event.type === 'message_start' && Array.isArray(event.message?.content)) {
+    initializeStreamContentIndexMap(event.message.content, state);
+    const sanitized = sanitizeAnthropicCompatiblePayload(event.message);
+    return sanitized.changed ? {...event, message: sanitized.payload} : event;
+  }
 
-        bodyJson.model = newModel;
-      }
+  if (event.type === 'content_block_start') {
+    const originalIndex = event.index;
 
-      const payload = bodyJson ? JSON.stringify(bodyJson) : bodyBuffer;
-      await forwardRequest(req, res, {
-        baseUrl,
-        bodyLength: typeof payload === 'string' ? Buffer.byteLength(payload) : payload.length,
-        debug,
-        onDebug,
-        onError,
-        payload,
-        timeout: 120000,
-        validToken,
-      });
-    } catch (error) {
-      onError(`[Proxy Error] POST ${MESSAGES_PATH}: ${error.message}`);
-      writeJsonError(res, 500, {
-        error: {
-          message: 'Scionos Proxy Error',
-          details: error.message,
-        },
-      });
+    if (isReasoningContentBlock(event.content_block)) {
+      state.droppedIndexes.add(originalIndex);
+      return null;
     }
-  });
-}
 
-async function forwardRequest(req, res, options) {
-  const {baseUrl, bodyLength, debug, onDebug, onError, payload, timeout, validToken} = options;
-  const https = await import('node:https');
-  const url = new URL(`${baseUrl}${req.url}`);
-  const requestOptions = buildProxyRequestOptions(
-    url,
-    req.method,
-    req.headers,
-    validToken,
-    bodyLength,
-    timeout,
-  );
+    const mappedIndex = getOrCreateMappedContentIndex(originalIndex, state);
+    return {...event, index: mappedIndex};
+  }
 
-  const proxyReq = https.request(requestOptions, (proxyRes) => {
-    if (debug) {
-      onDebug(`[Proxy] Upstream response status: ${proxyRes.statusCode}`);
+  if (event.type === 'content_block_delta' || event.type === 'content_block_stop') {
+    const originalIndex = event.index;
+    if (state.droppedIndexes.has(originalIndex)) {
+      return null;
     }
 
-    res.writeHead(proxyRes.statusCode, proxyRes.headers);
-    proxyRes.pipe(res);
-  });
-
-  proxyReq.on('error', (error) => {
-    onError(`[Proxy Error] ${req.method} ${req.url}: ${error.message}`);
-    if (debug && error.code) {
-      onError(`[Proxy Error] Code: ${error.code}`);
+    if (REASONING_DELTA_TYPES.has(event.delta?.type)) {
+      state.droppedIndexes.add(originalIndex);
+      return null;
     }
 
-    writeJsonError(res, req.method === 'POST' && getRequestPath(req) === MESSAGES_PATH ? 500 : 502, {
-      error: {
-        message: req.method === 'POST' && getRequestPath(req) === MESSAGES_PATH
-          ? 'Proxy Error'
-          : 'Scionos Proxy Error: Failed to connect to upstream',
-        details: error.message,
-        ...(error.code ? {code: error.code} : {}),
-      },
-    });
-  });
-
-  proxyReq.on('timeout', () => {
-    onError('[Proxy] Request timeout');
-    proxyReq.destroy();
-    writeJsonError(res, 504, {error: {message: 'Gateway Timeout'}});
-  });
-
-  if (payload !== undefined) {
-    proxyReq.write(payload);
-    proxyReq.end();
-    if (debug) {
-      onDebug('[Proxy] Request sent to upstream');
+    if (!state.indexMap.has(originalIndex)) {
+      return event;
     }
-    return;
-  }
 
-  if (req.method === 'POST' || req.method === 'PUT') {
-    req.pipe(proxyReq);
-  } else {
-    proxyReq.end();
+    return {...event, index: state.indexMap.get(originalIndex)};
   }
+
+  return event;
 }
 
-function startProxyServer(targetModel, validToken, options = {}) {
-  const {
-    availableModels = [],
-    baseUrl = BASE_URL,
-    debug = false,
-    onDebug = () => {},
-    onError = () => {},
-    proxySecret = null,
-  } = options;
-
-  return new Promise((resolve, reject) => {
-    const server = http.createServer((req, res) => {
-      if (!isAuthorizedProxyRequest(req, proxySecret)) {
-        writeJsonError(res, 403, {error: {message: 'Forbidden'}});
-        return;
-      }
+function initializeStreamContentIndexMap(content, state) {
+  for (const [originalIndex, block] of content.entries()) {
+    if (state.droppedIndexes.has(originalIndex) || state.indexMap.has(originalIndex)) {
+      continue;
+    }
 
-      if (!isAllowedProxyRoute(req)) {
-        writeJsonError(res, 404, {error: {message: 'Not Found'}});
-        return;
-      }
+    if (isReasoningContentBlock(block)) {
+      state.droppedIndexes.add(originalIndex);
+      continue;
+    }
 
-      handleMessageRequest(req, res, {
-        availableModels,
-        baseUrl,
-        debug,
-        onDebug,
-        onError,
-        targetModel,
-        validToken,
-      });
-    });
+    state.indexMap.set(originalIndex, state.nextIndex);
+    state.nextIndex += 1;
+  }
+}
 
-    server.listen(0, '127.0.0.1', () => {
-      const address = server.address();
-      resolve({server, url: `http://127.0.0.1:${address.port}`});
-    });
+function getOrCreateMappedContentIndex(originalIndex, state) {
+  if (!state.indexMap.has(originalIndex)) {
+    state.indexMap.set(originalIndex, state.nextIndex);
+    state.nextIndex += 1;
+  }
 
-    server.on('error', (error) => reject(error));
-  });
+  return state.indexMap.get(originalIndex);
 }
-
-export {
+
+function startProxyServer(targetModel, validToken, options = {}) {
+  const {
+    availableModels = [],
+    baseUrl = BASE_URL,
+    debug = false,
+    onDebug = () => {},
+    onError = () => {},
+    proxySecret = null,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      if (!isAuthorizedProxyRequest(req, proxySecret)) {
+        writeJsonError(res, 403, {error: {message: 'Forbidden'}});
+        return;
+      }
+
+      if (!isAllowedProxyRoute(req)) {
+        writeJsonError(res, 404, {error: {message: 'Not Found'}});
+        return;
+      }
+
+      handleMessageRequest(req, res, {
+        availableModels,
+        baseUrl,
+        debug,
+        onDebug,
+        onError,
+        targetModel,
+        validToken,
+      });
+    });
+
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      resolve({server, url: `http://127.0.0.1:${address.port}`});
+    });
+
+    server.on('error', (error) => reject(error));
+  });
+}
+
+export {
   buildProxyRequestOptions,
   normalizeProxyHeaders,
   PROXY_AUTH_HEADER,
   resolveMappedModel,
+  sanitizeAnthropicCompatiblePayload,
+  sanitizeAnthropicStreamEvent,
   startProxyServer,
 };

package/src/routerlab.js

@@ -114,9 +114,9 @@ const STRATEGIES = [
     value: 'deepseek-v4-beta',
     name: 'deepseek-v4 beta',
     selectionName: 'deepseek-v4 beta',
-    description: 'Maps Claude requests to the deepseek-v4 family. Opus 4.7 => deepseek-v4-pro, Sonnet 4.6 => deepseek-v4-flash, Haiku => deepseek-v4-flash.',
-    selectionDescription: 'Opus 4.7 => deepseek-v4-pro, Sonnet 4.6 => deepseek-v4-flash, Haiku => deepseek-v4-flash.',
-    verificationModels: ['deepseek-v4-pro', 'deepseek-v4-flash'],
+    description: 'Maps Claude requests to the deepseek-v4 family. Opus 4.7 => claude-deepseek-v4-pro, Sonnet 4.6 => claude-deepseek-v4-pro, Haiku => claude-deepseek-v4-flash.',
+    selectionDescription: 'Opus 4.7 => claude-deepseek-v4-pro, Sonnet 4.6 => claude-deepseek-v4-pro, Haiku => claude-deepseek-v4-flash.',
+    verificationModels: ['claude-deepseek-v4-pro', 'claude-deepseek-v4-flash'],
   },
   {
     value: 'claude-qwen3.6-plus',