dsh-think-translate 1.2.10 → 1.2.12

package/README.de.md

@@ -75,6 +75,10 @@ Für DSH **0.2.0-rc.2** verwenden Sie **dsh-think-translate 1.2.5 oder neuer**.
 
 **1.2.8 Übertragung und Wiederaufnahme:** Normale HTTP/HTTPS-Übersetzungen nutzen die nativen Netzwerkfunktionen von Node statt eines curl-Prozesses pro Textpaket. SOCKS-Proxys und der Ollama-Installer verwenden weiterhin curl. Fehler bleiben 30 Sekunden im Arbeitsspeicher; danach werden Denk- und Antwortübersetzungen automatisch erneut versucht. Die Zeitlimits berücksichtigen das Laden lokaler Modelle und alternative Anbieter.
 
+**1.2.12:** Die Anbieterschalter gelten verbindlich; nach einem Host-Fehler fragt der Browser Google nicht mehr direkt ab. Eingezäunter, eingerückter und Inline-Code wird nicht an Übersetzungsdienste gesendet und exakt wiederhergestellt, auch bei unvollständigem Streaming. Alte Übersetzungs-Caches werden entfernt, Einstellungen bleiben erhalten. Nach dem Update DSH Web oder Desktop vollständig neu starten; bloßes Neuladen kann weiterhin alte Client-Ressourcen verwenden.
+
+**1.2.11 Bing-Korrekturen:** Der kostenlose Bing-Anbieter bleibt erhalten. Übersetzungsanfragen gehen an den endgültigen Origin der Sitzungsseite, damit die Weiterleitung `www.bing.com` → `cn.bing.com` in Festlandchina den POST-Body nicht verwirft. SOCKS/curl verwendet dieselben Browser-Header wie der native Transport und behebt damit HTTP 401; leere Antworten und Antworten ohne JSON melden klare Fehler.
+
 **1.2.10 DSH-Profilkompatibilität:** Die Erkennung folgt dem laufenden Desktop/Web-Profil und liest `profiles/<profile>/cordis.patch.yml` (`id` + `config`), danach die Home-Patches und Start-Overlays. Das ältere `settings.yaml` bleibt unterstützt. Die Standardmodell-Zeile heißt `default-model`; Zugangsdaten bleiben in `.credentials.yaml` im DSH-Home und nur im Arbeitsspeicher. Die Diagnose zeigt die tatsächlich gelesene Datei.
 
 **1.2.9 Sprachkorrekturen:** Japanische Vokabelhinweise gelten nur für Japanisch; OpenAI/Anthropic erhalten den vollständigen Sprachnamen. Bing nutzt `auto-detect` und `zh-Hans`/`zh-Hant`. Die Erkennung chinesischer Prosa blendet Pfade, Code und JSON aus: vereinfachte Prosa wird übersprungen, häufige traditionelle Schriftzeichen lösen eine Übersetzungsanfrage aus, japanische/koreanische Prosa wird übersetzt. Alte Übersetzungen werden einmalig aus dem Cache entfernt; Einstellungen bleiben erhalten.
@@ -98,7 +102,7 @@ Browser → POST /_xlate/translate (gleiche Origin, kein CORS)
       chain: [provider1, provider2, ...]   ← Reihenfolge per Drag in den Einstellungen
         google / bing / OpenAI-kompatibel / Anthropic
       Fallback-Kette (optional, standardmäßig aus, in der Config aktivierbar)
-  → direkter Browser-Fallback
+  → Originaltext, wenn alle aktivierten Anbieter fehlschlagen
 ```
 
 - Die **Anbieter-Konfiguration** liegt in `config.json` (zur Laufzeit erzeugt, gitignoriert): `chain` (geordnete IDs), `fallback` (enabled + chain, nur Datei), `providers` (je Anbieter `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`). Alte `priority`-Konfigurationen werden automatisch migriert; ein Anbieter mit `apiKeyEnv` löst seinen Schlüssel pro Anfrage aus dieser Umgebungsvariable auf (der literale `apiKey` bleibt als Rückfall) und kein aufgelöster Schlüssel wird je in `config.json` zurückgeschrieben; ein `null` in einem Patch löscht das Feld — so leert die Oberfläche eines

package/README.es.md

@@ -75,6 +75,10 @@ Para DSH **0.2.0-rc.2**, usa **dsh-think-translate 1.2.5 o posterior**. La versi
 
 **1.2.8 transporte y recuperación:** las traducciones HTTP/HTTPS normales usan la red nativa de Node en lugar de iniciar curl por cada lote de texto. Los proxies SOCKS y el instalador de Ollama conservan la compatibilidad con curl. Los fallos permanecen en memoria durante 30 segundos y después se reintentan automáticamente las traducciones del razonamiento y las respuestas. Los tiempos de espera permiten cargar modelos locales y probar proveedores alternativos.
 
+**1.2.12:** se respetan los proveedores habilitados; el navegador ya no consulta Google directamente si falla el Host. El código delimitado, con sangría o en línea se excluye de las solicitudes y se conserva exactamente, incluso durante streaming incompleto. Se elimina la caché de traducciones anterior y se conservan las preferencias. Tras actualizar, reinicia por completo DSH Web o Desktop; recargar la página puede seguir usando recursos antiguos del cliente.
+
+**1.2.11 correcciones de Bing:** se mantiene el proveedor gratuito. Las solicitudes de traducción usan el origen final de la página de sesión para evitar que la redirección `www.bing.com` → `cn.bing.com` en China continental elimine el cuerpo POST. SOCKS/curl comparte las cabeceras de navegador del transporte nativo para corregir HTTP 401; las respuestas vacías o no JSON muestran errores claros.
+
 **1.2.10 compatibilidad con perfiles DSH:** el descubrimiento sigue el perfil Desktop/Web activo y lee `profiles/<profile>/cordis.patch.yml` (`id` + `config`), después los parches del directorio DSH y las superposiciones de inicio. Se mantiene el formato anterior `settings.yaml`. El modelo predeterminado usa `default-model`; las credenciales siguen en `.credentials.yaml` del directorio DSH y solo en memoria. El diagnóstico muestra el archivo leído.
 
 **1.2.9 correcciones de idioma:** las pistas de vocabulario japonés solo se aplican al japonés; OpenAI/Anthropic reciben el nombre completo del idioma. Bing usa `auto-detect` y `zh-Hans`/`zh-Hant`. La detección del chino excluye rutas, código y JSON: omite la prosa ya simplificada, solicita conversión al detectar caracteres tradicionales frecuentes y traduce la prosa japonesa/coreana. Se elimina una vez la caché de traducciones anterior, conservando los ajustes.
@@ -98,7 +102,7 @@ navegador → POST /_xlate/translate (mismo origen, sin CORS)
       chain: [provider1, provider2, ...]   ← orden arrastrando en Ajustes
         google / bing / compatible con OpenAI / Anthropic
       cadena fallback (opcional, desactivada por defecto, se activa en el config)
-  → respaldo directo desde el navegador
+  → texto original si fallan todos los proveedores habilitados
 ```
 
 - La **configuración de proveedores** vive en `config.json` (generado en tiempo de ejecución, ignorado por git): `chain` (ids ordenados), `fallback` (enabled + chain, solo en el archivo), `providers` (por proveedor `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`). Las configuraciones antiguas con `priority` se migran solas; un proveedor que declara `apiKeyEnv` resuelve la clave desde esa variable en cada petición (el `apiKey` literal queda como respaldo) y ninguna clave resuelta se escribe de vuelta en `config.json`; un `null` en un parche borra ese campo, que es como la interfaz vacía uno

package/README.fr.md

@@ -75,6 +75,10 @@ Pour DSH **0.2.0-rc.2**, utilisez **dsh-think-translate 1.2.5 ou une version ult
 
 **1.2.8 transport et reprise :** les traductions HTTP/HTTPS ordinaires utilisent le réseau natif de Node au lieu de lancer curl pour chaque lot de texte. Les proxys SOCKS et l’installateur Ollama conservent curl. Les échecs restent en mémoire pendant 30 secondes, puis les traductions du raisonnement et des réponses sont réessayées automatiquement. Les délais tiennent compte du chargement des modèles locaux et du recours à d’autres fournisseurs.
 
+**1.2.12 :** les choix de fournisseurs sont respectés ; le navigateur ne contacte plus Google directement après un échec du Host. Le code délimité, indenté ou en ligne est exclu des requêtes et conservé exactement, y compris pendant un flux incomplet. Les anciennes traductions en cache sont supprimées, les préférences conservées. Après la mise à jour, redémarrez entièrement DSH Web ou Desktop ; une simple actualisation peut encore référencer les anciennes ressources du client.
+
+**1.2.11 corrections de Bing :** le fournisseur gratuit est conservé. Les requêtes de traduction utilisent l’origine finale de la page de session pour éviter que la redirection `www.bing.com` → `cn.bing.com` en Chine continentale supprime le corps POST. SOCKS/curl utilise les mêmes en-têtes de navigateur que le transport natif pour corriger HTTP 401 ; les réponses vides ou non JSON signalent des erreurs explicites.
+
 **1.2.10 compatibilité des profils DSH :** la détection suit le profil Desktop/Web actif et lit `profiles/<profile>/cordis.patch.yml` (`id` + `config`), puis applique les correctifs du répertoire DSH et les surcharges de lancement. L’ancien `settings.yaml` reste pris en charge. Le modèle par défaut utilise `default-model` ; les identifiants restent dans `.credentials.yaml` du répertoire DSH et en mémoire uniquement. Le diagnostic indique le fichier lu.
 
 **1.2.9 corrections linguistiques :** les indications de vocabulaire japonais ne concernent que le japonais ; OpenAI/Anthropic reçoivent le nom complet de la langue. Bing utilise `auto-detect` et `zh-Hans`/`zh-Hant`. La détection du chinois écarte chemins, code et JSON : elle ignore la prose déjà simplifiée, demande une conversion en présence de caractères traditionnels courants et traduit la prose japonaise/coréenne. Les anciennes traductions en cache sont supprimées une fois, sans toucher aux réglages.
@@ -98,7 +102,7 @@ navigateur → POST /_xlate/translate (même origine, sans CORS)
       chain: [provider1, provider2, ...]   ← ordre par glisser dans les Réglages
         google / bing / compatible OpenAI / Anthropic
       chaîne fallback (facultative, désactivée par défaut, activable dans la config)
-  → repli direct depuis le navigateur
+  → texte original si tous les fournisseurs activés échouent
 ```
 
 - La **configuration des fournisseurs** vit dans `config.json` (généré à l'exécution, ignoré par git) : `chain` (ids ordonnés), `fallback` (enabled + chain, fichier uniquement), `providers` (par fournisseur `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`). Les anciennes configurations `priority` sont migrées automatiquement ; un fournisseur qui déclare `apiKeyEnv` résout sa clé depuis cette variable à chaque requête (le `apiKey` littéral reste en secours) et aucune clé résolue n'est réécrite dans `config.json` ; un `null` dans un patch supprime ce champ, c'est ainsi que l'interface en vide un

package/README.ja.md

@@ -75,6 +75,10 @@ DSH **0.2.0-rc.2** では **dsh-think-translate 1.2.5 以降**を使用してく
 
 **1.2.8 通信と復帰：**通常の HTTP/HTTPS 翻訳は、テキストのバッチごとに curl を起動せず Node の標準ネットワーク機能を使います。SOCKS プロキシと Ollama インストーラーは引き続き curl に対応します。失敗結果をメモリ内に30秒間保持し、その後は思考・回答の翻訳を自動再試行します。タイムアウトはローカルモデルのロードと代替プロバイダーへの切り替えを考慮しています。
 
+**1.2.12：**提供元の設定に従い、Host の失敗後にブラウザーから Google へ直接送信しません。フェンス付き・インデント付き・インラインコードは翻訳対象から除外し、ストリーミング中の未完了コードも原文のまま保持します。古い訳文キャッシュを削除し、設定は保持します。 更新後は DSH Web または Desktop を完全に再起動してください。ページの更新だけでは古いクライアント資源を参照する場合があります。
+
+**1.2.11 Bing 修正：**無料の Bing を引き続き提供します。翻訳リクエストはセッションページの最終オリジンに送信し、中国本土の `www.bing.com` → `cn.bing.com` リダイレクトによる POST 本文の消失を防ぎます。SOCKS/curl はネイティブ通信と同じブラウザーヘッダーを使用して HTTP 401 を修正。空の応答と JSON 以外の応答には明確なエラーを表示します。
+
 **1.2.10 DSH プロファイル対応：**実行中の Desktop/Web プロファイルに従い、`profiles/<profile>/cordis.patch.yml`（`id` + `config`）、DSH home のパッチ、起動時のオーバーレイを順に読み込みます。旧形式の `settings.yaml` も対応。既定モデル行は `default-model` に対応し、資格情報は DSH home の `.credentials.yaml` から解決してメモリ内だけに保持します。再スキャン時に実際の設定パスを表示します。
 
 **1.2.9 言語修正：**日本語の語彙ヒントは日本語の翻訳先に限定し、OpenAI/Anthropic に完全な言語名を渡します。Bing は `auto-detect` と `zh-Hans`/`zh-Hant` を使用。中国語の判定ではパス・コード・JSON を除外し、簡体字の本文はスキップ、よく使われる繁体字を検出すると変換を依頼、日本語・韓国語の本文は翻訳します。旧訳文キャッシュを一度削除し、設定は保持します。
@@ -98,7 +102,7 @@ DSH **0.2.0-rc.2** では **dsh-think-translate 1.2.5 以降**を使用してく
       chain: [provider1, provider2, ...]   ← 設定でドラッグして並べ替え
         google / bing / OpenAI 互換 / Anthropic から選択
       fallback チェーン（任意、既定は無効、設定で有効化）
-  → ブラウザ直結のフォールバック
+  → 有効な提供元がすべて失敗した場合は原文を保持
 ```
 
 - **プロバイダー設定** は `config.json`（実行時生成・gitignore 対象）にあります：`chain`（順序付き ID）、`fallback`（enabled と chain、設定ファイル専用）、`providers`（各項目の `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`）。旧 `priority` 形式は自動移行されます。`apiKeyEnv` を宣言した提供元はリクエスト時にその環境変数からキーを解決し（リテラル `apiKey` はフォールバック）、解決したキーを `config.json` に書き戻すことはありません。パッチ内の `null` はそのフィールドの削除を意味し、UI のクリアはこれを使っています

package/README.ko.md

@@ -75,6 +75,10 @@ DSH **0.2.0-rc.2**에서는 **dsh-think-translate 1.2.5 이상**을 사용하세
 
 **1.2.8 전송 및 복구:** 일반 HTTP/HTTPS 번역은 텍스트 배치마다 curl을 실행하는 대신 Node 기본 네트워크 기능을 사용합니다. SOCKS 프록시와 Ollama 설치 프로그램은 curl 호환 경로를 유지합니다. 실패 결과를 메모리에 30초간 보관한 뒤 사고·답변 번역을 자동 재시도합니다. 타임아웃은 로컬 모델 로드와 다른 제공자로의 전환 시간을 고려합니다.
 
+**1.2.12:** 제공자 설정을 준수하며 Host 실패 후 브라우저에서 Google로 직접 요청하지 않습니다. 코드 블록, 들여쓰기 코드, 인라인 코드는 번역 서비스에 보내지 않고 원문 그대로 복원합니다. 스트리밍 중 닫히지 않은 코드도 보호하며, 이전 번역 캐시만 삭제하고 설정은 유지합니다. 업데이트 후 DSH Web 또는 Desktop을 완전히 다시 시작하세요. 페이지 새로고침만으로는 이전 클라이언트 리소스가 남을 수 있습니다.
+
+**1.2.11 Bing 수정:** 무료 Bing 제공자를 유지합니다. 세션 페이지의 최종 출처로 번역 요청을 보내 중국 본토의 `www.bing.com` → `cn.bing.com` 리디렉션에서 POST 본문이 사라지는 문제를 방지합니다. SOCKS/curl도 네이티브 통신과 같은 브라우저 헤더를 사용해 HTTP 401을 수정하며, 빈 응답과 JSON이 아닌 응답에 명확한 오류를 표시합니다.
+
 **1.2.10 DSH 프로필 호환:** 실행 중인 Desktop/Web 프로필의 `profiles/<profile>/cordis.patch.yml`(`id` + `config`)을 읽고 DSH 홈 패치와 시작 오버레이를 순서대로 적용합니다. 이전 `settings.yaml`도 지원합니다. 기본 모델 행은 `default-model`을 지원하며 자격 증명은 DSH 홈의 `.credentials.yaml`에서 읽어 메모리에만 유지합니다. 다시 검사하면 실제 설정 경로가 표시됩니다.
 
 **1.2.9 언어 수정:** 일본어 어휘 힌트는 일본어 대상에만 적용하며 OpenAI/Anthropic에 전체 언어 이름을 전달합니다. Bing은 `auto-detect`와 `zh-Hans`/`zh-Hant`를 사용합니다. 중국어 감지 시 경로·코드·JSON을 제외하고, 이미 간체인 본문은 건너뛰며 자주 쓰는 번체 글자를 감지하면 변환을 요청합니다. 일본어·한국어 본문은 번역합니다. 이전 번역 캐시만 한 번 삭제하고 설정은 유지합니다.
@@ -98,7 +102,7 @@ DSH **0.2.0-rc.2**에서는 **dsh-think-translate 1.2.5 이상**을 사용하세
       chain: [provider1, provider2, ...]   ← 설정에서 드래그로 정렬
         google / bing / OpenAI 호환 / Anthropic 중 선택
       fallback 체인(선택, 기본 비활성, 설정에서 활성화)
-  → 브라우저 직접 연결 폴백
+  → 활성 제공자가 모두 실패하면 원문 유지
 ```
 
 - **제공자 설정**은 `config.json`(런타임 생성, gitignore 대상)에 있습니다: `chain`(순서 있는 id), `fallback`(enabled + chain, 설정 파일 전용), `providers`(각 항목의 `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`). 예전 `priority` 형식은 자동 마이그레이션됩니다. `apiKeyEnv`를 선언한 제공자는 요청 시 해당 환경 변수에서 키를 해석하며(리터럴 `apiKey`는 폴백), 해석된 키를 `config.json`에 다시 쓰지 않습니다. 패치의 `null`은 해당 필드 삭제를 뜻하며 UI가 그렇게 비웁니다

package/README.md

@@ -72,6 +72,10 @@ Version **1.2.6** fixes duplicated thinking and answer text in DSH 0.2: the assi
 
 **1.2.8 transport and recovery:** ordinary HTTP/HTTPS translation requests use native Node networking instead of spawning curl per text batch; SOCKS proxies and the Ollama installer retain curl compatibility. Failures stay in memory for 30 seconds, then reasoning and answer translation resume automatically. Request deadlines allow time for local-model loading and provider fallback.
 
+**1.2.12:** provider switches are authoritative: the browser no longer sends direct Google requests after Host failure. Fenced, indented and inline code is excluded from translation payloads and restored exactly, including unfinished streaming spans. Old translation caches are discarded; preferences are retained. After upgrading, fully restart DSH Web or Desktop; a page refresh alone may still reference old client resources.
+
+**1.2.11 Bing fixes:** the free Bing provider is retained. Translation requests use the session page's final origin, preventing the mainland China `www.bing.com` → `cn.bing.com` redirect from dropping the POST body. SOCKS/curl now shares the native browser headers to fix HTTP 401; empty and non-JSON responses report clear errors.
+
 **1.2.10 DSH profile compatibility:** discovery follows the running Desktop/Web profile and reads `profiles/<profile>/cordis.patch.yml` (`id` + `config`), with home patches and launcher overlays applied afterward. Legacy `settings.yaml` is still supported. Default model rows use `default-model`; credentials remain in the DSH home `.credentials.yaml` and stay in memory. Rescan diagnostics show the file actually read.
 
 **1.2.9 language fixes:** Japanese vocabulary hints now apply only to Japanese targets; OpenAI/Anthropic requests include a full language name. Bing uses `auto-detect` and maps Chinese targets to `zh-Hans`/`zh-Hant`. Chinese detection examines prose after removing paths, code and JSON: already-Simplified prose is skipped, common Traditional script cues request conversion, and Japanese/Korean prose is translated. Old persisted translation results are cleared once; settings remain intact.
@@ -100,7 +104,7 @@ browser → POST /_xlate/translate (same-origin, no CORS)
           openai   (OpenAI-compatible /chat/completions — Ollama local or any gateway)
           anthropic(Anthropic Messages API /v1/messages)
       fallback chain (config-only, off by default) tried when the primary chain fails entirely
-  → browser-direct fallback
+  → original text if all enabled providers fail
 ```
 
 - **Provider config** lives in `config.json` (runtime, gitignored): `chain` (ordered ids), `fallback` (enabled + chain, config-only), `providers` (per-provider `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`). Old `priority`-based configs auto-migrate. A provider that declares `apiKeyEnv` resolves its key from that environment variable at request time (the literal `apiKey` stays as the fallback), and no env-resolved key is ever written back to `config.json`. A `null` field in a config patch deletes that field, which is how the UI clears one.

package/README.ru.md

@@ -75,6 +75,10 @@ New-Item -ItemType Junction -Path "$HOME\.dsh\profiles\node_modules\dsh-think-tr
 
 **1.2.8 передача запросов и восстановление:** обычные HTTP/HTTPS-запросы перевода используют сетевые средства Node без запуска curl для каждого пакета текста. Для SOCKS-прокси и установщика Ollama сохранён путь через curl. Ошибки хранятся в памяти 30 секунд, после чего перевод рассуждений и ответов автоматически повторяется. Тайм-ауты учитывают загрузку локальной модели и переход к другим провайдерам.
 
+**1.2.12:** настройки провайдеров соблюдаются: после ошибки Host браузер больше не обращается к Google напрямую. Блочный код, код с отступом и встроенный код исключаются из запросов и сохраняются точно, включая незавершённые потоковые фрагменты. Старый кеш переводов очищается, настройки сохраняются. После обновления полностью перезапустите DSH Web или Desktop: простое обновление страницы может продолжить использовать старые ресурсы клиента.
+
+**1.2.11 исправления Bing:** бесплатный провайдер сохранён. Запросы перевода отправляются на конечный origin страницы сеанса, чтобы перенаправление `www.bing.com` → `cn.bing.com` в материковом Китае не удаляло тело POST. SOCKS/curl использует те же заголовки браузера, что и нативный транспорт, устраняя HTTP 401; пустые ответы и ответы не в формате JSON дают понятные ошибки.
+
 **1.2.10 совместимость с профилями DSH:** обнаружение следует активному профилю Desktop/Web и читает `profiles/<profile>/cordis.patch.yml` (`id` + `config`), затем патчи домашнего каталога DSH и параметры запуска. Прежний `settings.yaml` поддерживается. Модель по умолчанию использует `default-model`; ключи читаются из `.credentials.yaml` домашнего каталога DSH и остаются только в памяти. Диагностика показывает прочитанный файл.
 
 **1.2.9 языковые исправления:** подсказки японской лексики применяются только к японскому; OpenAI/Anthropic получают полное название языка. Bing использует `auto-detect` и `zh-Hans`/`zh-Hant`. Определение китайского исключает пути, код и JSON: упрощённая проза пропускается, частые традиционные иероглифы вызывают запрос преобразования, японская/корейская проза переводится. Старый кэш переводов очищается один раз, настройки сохраняются.
@@ -98,7 +102,7 @@ New-Item -ItemType Junction -Path "$HOME\.dsh\profiles\node_modules\dsh-think-tr
       chain: [provider1, provider2, ...]   ← порядок перетаскиванием в настройках
         google / bing / OpenAI-совместимый / Anthropic
       fallback-цепочка (необязательно, по умолчанию выключена, включается в конфиге)
-  → прямой запасной путь из браузера
+  → исходный текст, если все включённые провайдеры недоступны
 ```
 
 - **Конфигурация провайдеров** живёт в `config.json` (создаётся во время работы, в gitignore): `chain` (упорядоченные id), `fallback` (enabled + chain, только в файле), `providers` (у каждого `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`). Старые конфиги с `priority` мигрируют автоматически; провайдер с `apiKeyEnv` разрешает ключ из этой переменной на каждый запрос (литеральный `apiKey` остаётся запасным), и разрешённый ключ никогда не пишется обратно в `config.json`; `null` в патче удаляет поле — так интерфейс и очищает значения

package/README.zh-CN.md

@@ -75,6 +75,10 @@ DSH **0.2.0-rc.2** 请使用 **dsh-think-translate 1.2.5 或更新版本**。1.2
 
 **1.2.8 传输与恢复：**普通 HTTP/HTTPS 翻译请求改用 Node 原生网络，不再为每个文本批次启动 curl；SOCKS 代理和 Ollama 安装器保留 curl 兼容路径。失败结果在内存缓存 30 秒，冷却结束后思考与回答翻译会自动恢复重试。请求超时为本地模型加载和提供方回退留出时间。
 
+**1.2.12：**提供方开关统一由 Host 执行，失败后浏览器不再直连 Google。围栏代码、缩进代码和行内代码不发送给翻译服务，按原文精确拼回；流式输出中尚未闭合的代码同样保护。清理旧译文缓存，保留设置。 升级后请完整重启 DSH Web 或 Desktop；仅刷新页面可能继续引用旧客户端资源。
+
+**1.2.11 Bing 修复：**保留免费 Bing 通道。翻译请求跟随会话页最终域名，避免国内 `www.bing.com` → `cn.bing.com` 跳转丢失 POST 正文；SOCKS/curl 同步原生浏览器请求头，修复 HTTP 401。空响应和非 JSON 响应给出明确错误。
+
 **1.2.10 DSH 配置兼容：**发现提供方时跟随当前 Desktop/Web profile，读取 `profiles/<profile>/cordis.patch.yml`（`id` + `config`），随后应用 home 补丁与启动覆盖；继续支持旧版 `settings.yaml`。默认模型行支持 `default-model`，凭据仍从 DSH home 的 `.credentials.yaml` 解析且只留在内存；重新扫描会显示实际读取的配置路径。
 
 **1.2.9 语言修复：**日语词汇提示仅用于日语目标，OpenAI/Anthropic 请求带上完整语言名称。Bing 使用 `auto-detect`，并将中文目标映射为 `zh-Hans`/`zh-Hant`。中文检测先排除路径、代码和 JSON：已是简体的正文跳过，常用繁体区别字触发转换请求，日语/韩语正文正常翻译。升级时一次性清理旧译文缓存，保留设置。
@@ -98,7 +102,7 @@ DSH **0.2.0-rc.2** 请使用 **dsh-think-translate 1.2.5 或更新版本**。1.2
       chain: [provider1, provider2, ...]   ← 设置里拖拽排序
         google / bing / openai 兼容 / anthropic 任选
       fallback 链（可选，默认关闭，配置里开启）
-  → 浏览器直连兜底
+  → 所有已启用提供方失败时保留原文
 ```
 
 - **提供方配置** 存在 `config.json`（运行期生成，已 gitignore）：`chain`（有序 id）、`fallback`（enabled + chain，仅配置文件）、`providers`（每项的 `type`/`enabled`/`baseURL`/`apiKey`/`apiKeyEnv`/`model`）。旧的 `priority` 配置会自动迁移；声明 `apiKeyEnv` 的提供方在请求时从该环境变量解析密钥（字面 `apiKey` 作为兜底），解析出的密钥绝不写回 `config.json`；patch 里显式的 `null` 表示删除该字段，UI 就是用它清空字段的

package/lib/client.js

@@ -23,7 +23,7 @@ window.__ModuleLoader__.load({
 		// there yet (an older process still serving the port), and the contract test
 		// pins PLUGIN_VERSION to package.json so the two can never drift.
 		var PLUGIN_NAME = "dsh-think-translate";
-		var PLUGIN_VERSION = "1.2.10";
+		var PLUGIN_VERSION = "1.2.12";
 		var PLUGIN_REPO = "https://github.com/UncleK/dsh-think-translate";
 		// The official MarkdownText contract changed in 0.1.2-alpha: it now takes a
 		// nested `labels` object and dereferences it without defaults inside its code
@@ -653,8 +653,7 @@ window.__ModuleLoader__.load({
 		};
 
 		// ------------------------------------------------------------------
-		// translation pipeline (browser-side Google gtx; browser applies the
-		// system proxy automatically; endpoint returns CORS *)
+		// translation pipeline (same-origin Host owns provider routing)
 		// ------------------------------------------------------------------
 		var mem = new Map();
 		// Translation cache persisted to localStorage so switching sessions or
@@ -662,8 +661,8 @@ window.__ModuleLoader__.load({
 		// historical message (which wedged the UI when the local model was slow,
 		// 2026-08-26). In-memory map is the fast path; localStorage is the
 		// durable cross-session floor.
-		var MEM_KEY = "dsh-xlate-cache:v2:";
-        // Discard results produced before the prompt/language fixes, retaining settings.
+		var MEM_KEY = "dsh-xlate-cache:v3:";
+        // Discard old results that may contain translated code; retain preferences.
         try {
           var legacyKeys = [];
           for (var cacheIndex = 0; cacheIndex < localStorage.length; cacheIndex++) {
@@ -755,6 +754,70 @@ window.__ModuleLoader__.load({
 			return h.toString(36) + "." + s.length.toString(36);
 		}
 
+		// Inlined from text.js for the standalone client bundle; parity is tested.
+		function protectedTextParts(text) {
+		  const parts = []
+		  let proseStart = 0
+		  let cursor = 0
+		  function protect(start, end, complete) {
+		    if (start > proseStart) parts.push({ text: text.slice(proseStart, start), start: proseStart, end: start, code: false, complete: true })
+		    parts.push({ text: text.slice(start, end), start, end, code: true, complete })
+		    proseStart = end
+		    cursor = end
+		  }
+		  function lineEnd(start) {
+		    const newline = text.indexOf('\n', start)
+		    return newline < 0 ? text.length : newline + 1
+		  }
+		  while (cursor < text.length) {
+		    if (cursor === 0 || text[cursor - 1] === '\n') {
+		      const end = lineEnd(cursor)
+		      const line = text.slice(cursor, end)
+		      // Treat indented/quoted fences conservatively as code as well.
+		      const fence = line.match(/^[\t ]*(?:>[\t ]*)*(?:(?:[-+*]|[0-9]+[.)])[\t ]+)?(`{3,}|~{3,})[^\r\n]*(?:\r?\n)?$/)
+		      if (fence) {
+		        const close = new RegExp('^[\\t ]*(?:>[\\t ]*)*' + fence[1][0] + '{' + fence[1].length + ',}[\\t ]*(?:\\r?\\n)?$')
+		        let stop = end
+		        let complete = false
+		        while (stop < text.length) {
+		          const next = lineEnd(stop)
+		          if (close.test(text.slice(stop, next))) { stop = next; complete = true; break }
+		          stop = next
+		        }
+		        protect(cursor, stop, complete)
+		        continue
+		      }
+		      if (/^(?: {4}|\t)/.test(line)) {
+		        protect(cursor, end, end < text.length || line.endsWith('\n'))
+		        continue
+		      }
+		    }
+		    if (text[cursor] === '`') {
+		      let slashes = 0
+		      for (let i = cursor - 1; i >= 0 && text[i] === '\\'; i--) slashes++
+		      if (slashes % 2) { cursor++; continue }
+		      let after = cursor + 1
+		      while (text[after] === '`') after++
+		      const size = after - cursor
+		      let next = after
+		      let stop = text.length
+		      let complete = false
+		      while ((next = text.indexOf('`', next)) >= 0) {
+		        let end = next + 1
+		        while (text[end] === '`') end++
+		        if (end - next === size) { stop = end; complete = true; break }
+		        next = end
+		      }
+		      // An unfinished streaming code span must not expose its body as prose.
+		      protect(cursor, stop, complete)
+		      continue
+		    }
+		    cursor++
+		  }
+		  if (proseStart < text.length) parts.push({ text: text.slice(proseStart), start: proseStart, end: text.length, code: false, complete: true })
+		  return parts
+		}
+
 		function isCjk(code) {
 			return (code >= 0x3400 && code <= 0x4dbf) || (code >= 0x4e00 && code <= 0x9fff)
 				|| (code >= 0xf900 && code <= 0xfaff) || (code >= 0x20000 && code <= 0x2ffff)
@@ -778,9 +841,7 @@ window.__ModuleLoader__.load({
 			return /^(?:[$>#]\s*)?(?:(?:npm|pnpm|yarn|bun|npx|node|git|cd|curl|pwsh|reg)\b|(?:const|let|var|import|export|function|class|return|if|for|while|async|await)\b|[\[{(]|['"]?[\w.-]+['"]?\s*(?:[:=]|=>)|[\w$.]+\s*\(|(?:[~./][\w@~./-]*|[\w.-]+\/[\w@~./-]+)(?::\d+)?$)/.test(line);
 		}
 		function hasProse(text) {
-			var outside = text
-				.replace(/```[\s\S]*?```/g, " ")
-				.replace(/`[^`\n]*`/g, " ")
+			var outside = protectedTextParts(text).filter(function (part) { return !part.code; }).map(function (part) { return part.text; }).join(" ")
 				.replace(/https?:\/\/\S+/g, " ");
 			var lines = outside.split("\n").map(function (l) { return l.trim(); }).filter(Boolean);
 			if (lines.length === 0) return false;
@@ -790,7 +851,7 @@ window.__ModuleLoader__.load({
 		}
 		// Decide from prose, not paths, identifiers, or structured payloads (#10).
 		function proseForDetection(text) {
-		  let prose = text.replace(/```[\s\S]*?```/g, ' ').replace(/`[^`\n]*`/g, ' ')
+		  let prose = protectedTextParts(text).filter(function (part) { return !part.code; }).map(function (part) { return part.text; }).join(' ')
 		    .replace(/https?:\/\/[^\s<>]+/g, ' ')
 		    .replace(/\b[A-Za-z]:[\\/][^\s"'`,;，。；！？、)}\]]*/g, ' ')
 		    .replace(/(^|\s)\/(?:[^\s"'`,;，。；！？、)}\]]+)/g, '$1 ')
@@ -824,54 +885,6 @@ window.__ModuleLoader__.load({
 		  const traditionalTarget = !/(?:^|-)hans(?:-|$)/i.test(tag) && /(?:^|-)(?:hant|tw|hk|mo)(?:-|$)/i.test(tag)
 		  return (traditionalTarget ? SIMPLIFIED_CUES : TRADITIONAL_CUES).test(prose)
 		}
-		function chunkText(text) {
-			if (text.length <= 1200) return [text];
-			var sentences = text.match(/[\s\S]*?[.。！？!?;\n]|[\s\S]+$/g) || [text];
-			var chunks = [], cur = "";
-			for (var i = 0; i < sentences.length; i++) {
-				var sn = sentences[i];
-				if (cur && cur.length + sn.length > 1200) { chunks.push(cur); cur = ""; }
-				if (sn.length > 1200) {
-					for (var k = 0; k < sn.length; k += 1100) chunks.push(sn.slice(k, k + 1100));
-					cur = "";
-				} else {
-					cur += sn;
-				}
-			}
-			if (cur.trim()) chunks.push(cur);
-			return chunks.length ? chunks : [text];
-		}
-
-		async function gtxChunk(text, target) {
-			var qs = "translate_a/single?client=dict-chrome-ex&sl=auto&tl="
-				+ encodeURIComponent(target) + "&dt=t&q=" + encodeURIComponent(text);
-			// translate.googleapis.com is TLS-reset by Clash/GFW in CN networks;
-			// translate.google.com serves the same gtx JSON and is reachable there.
-			// Try both so CN and the rest of the world both work.
-			var hosts = ["https://translate.google.com/", "https://translate.googleapis.com/"];
-			var lastErr = null;
-			for (var hi = 0; hi < hosts.length; hi++) {
-				var url = hosts[hi] + qs;
-				// Bounded wait: when direct google is unreachable this must fail fast
-				// instead of hanging on the browser's own timeout (2026-08-22: direct
-				// gtx blocked in this network stalled every fallback for ~8s+).
-				try {
-					var res = await fetchWithTimeout(url, null, 6000);
-					if (!res.ok) throw new Error("gtx HTTP " + res.status);
-					var arr = await res.json();
-					var segs = arr && arr[0];
-					if (!Array.isArray(segs)) throw new Error("gtx unexpected shape");
-					var out = "";
-					for (var i = 0; i < segs.length; i++) {
-						if (Array.isArray(segs[i]) && typeof segs[i][0] === "string") out += segs[i][0];
-					}
-					if (!out.trim()) throw new Error("gtx empty translation");
-					return out;
-				} catch (e) { lastErr = e; }
-			}
-			throw lastErr || new Error("gtx unavailable");
-		}
-
 		function sleepMs(ms) { return new Promise(function (res) { setTimeout(res, ms); }); }
 
 		function fetchWithTimeout(url, opts, ms) {
@@ -929,14 +942,7 @@ window.__ModuleLoader__.load({
 						try { r = await hostAttempt(text, target); break; }
 						catch (e) { r = null; lastErr = e; if (e && e.retryAt > Date.now()) break; }
 					}
-					if (!(r && r.ok)) {
-						try {
-							var chunks = chunkText(text);
-							var outs = [];
-							for (var k = 0; k < chunks.length; k++) outs.push(await gtxChunk(chunks[k], target));
-							r = { ok: true, text: outs.join(""), provider: "google-direct" };
-						} catch (e2) { r = null; if (e2 && e2.message) lastErr = e2; }
-					}
+					// The Host alone owns routing and provider switches.
 					if (r && r.ok) {
 						if (r.providerSignature) recordCheck(r.provider, true, r.model, r.providerSignature);
 						stats.ok++; stats.lastError = null; stats.lastProvider = r.provider; stats.lastModel = r.model || null;
@@ -1025,12 +1031,15 @@ window.__ModuleLoader__.load({
 		function latestLine(t) { var v = t.trimEnd(); var i = v.lastIndexOf("\n"); return i === -1 ? v : v.slice(i + 1); }
 
 		function splitSentences(text) {
-			var re = /[^。！？!?;\n]*[。！？!?;\n]+|[^。！？!?;\n]+/g;
-			var out = [], m;
-			while ((m = re.exec(text)) !== null) {
-				if (m[0].length === 0) { re.lastIndex++; continue; }
-				out.push({ start: m.index, end: m.index + m[0].length, text: m[0] });
-			}
+			var out = [];
+			protectedTextParts(text).forEach(function (part) {
+				if (part.code) { out.push(part); return; }
+				var re = /[^。！？!?;\n]*[。！？!?;\n]+|[^。！？!?;\n]+/g, m;
+				while ((m = re.exec(part.text)) !== null) {
+					if (m[0].length === 0) { re.lastIndex++; continue; }
+					out.push({ start: part.start + m.index, end: part.start + m.index + m[0].length, text: m[0], code: false, complete: true });
+				}
+			});
 			return out;
 		}
 		var XL_STREAM_MARGIN = 120;
@@ -1086,7 +1095,7 @@ window.__ModuleLoader__.load({
 						// batches (local 7B models degrade on long blobs).
 						var batch = "", count = 0, nextIdx = cur.segIdx;
 						for (var i = cur.segIdx; i < segs.length; i++) {
-							if (isRunning && segs[i].end > latest.length - XL_STREAM_MARGIN) break;
+							if (isRunning && (!segs[i].complete || segs[i].end > latest.length - XL_STREAM_MARGIN)) break;
 							batch += segs[i].text;
 							nextIdx = i + 1;
 							count++;
@@ -1106,7 +1115,7 @@ window.__ModuleLoader__.load({
 							if (r && r.ok) {
 								next.failed = false;
 								next.retryAt = 0;
-								if (!r.skipped) next.transText = p.transText + r.text;
+								next.transText = p.transText + r.text;
 								next.segIdx = Math.max(p.segIdx, nextIdx);
 							} else {
 								// A negative-cache hit is a cooldown, not another failed

package/lib/index.js

@@ -11,8 +11,9 @@ import { tmpdir } from 'node:os'
 import { randomUUID } from 'node:crypto'
 import { createLocalPreparation, ollamaOrigin, localFirst, validOllamaSignature } from './ollama.js'
 import { fileURLToPath } from 'node:url'
-import { requestText, isLoopback } from './transport.js'
+import { requestTextInfo, isLoopback, DEFAULT_HEADERS } from './transport.js'
 import { scanDshProviders, extractDshProviders, extractCredRefs, extractHarnessDefaultRoute } from './discovery.js'
+import { protectedTextParts, translateProtectedText } from './text.js'
 
 export const name = 'dsh-think-translate'
 
@@ -332,24 +333,39 @@ async function curlArgs(extra) {
   return args.concat(extra)
 }
 
-async function httpFetch(url, options = {}, timeoutMs = 25000) {
+async function httpFetch(url, options = {}, timeoutMs = 25000, wantInfo = false) {
   const proxy = isLoopback(url) ? null : await getProxy()
   if (proxy && /^socks/i.test(proxy)) {
     const extra = ['--fail', '-L', '--max-time', String(Math.ceil(timeoutMs / 1000)), '-X', options.method || 'GET']
-    for (const [key, value] of Object.entries(options.headers || {})) extra.push('-H', key + ': ' + value)
+    // Bing rejects the default curl user agent with HTTP 401. Keep both
+    // transports' session and translation headers consistent.
+    for (const [key, value] of Object.entries({ ...DEFAULT_HEADERS, ...options.headers })) extra.push('-H', key + ': ' + value)
     if (options.body !== undefined) extra.push('--data-binary', options.body)
+    const marker = '\n__DSH_RESPONSE_INFO__\n'
+    if (wantInfo) extra.push('-w', marker + '%{url_effective}\n%{http_code}')
     extra.push(url)
-    return runProgram('curl', await curlArgs(extra), timeoutMs + 5000)
+    const out = await runProgram('curl', await curlArgs(extra), timeoutMs + 5000)
+    if (!wantInfo) return out
+    const at = out.lastIndexOf(marker)
+    if (at < 0) throw new Error('curl response metadata missing')
+    const [finalUrl, status] = out.slice(at + marker.length).trim().split(/\r?\n/)
+    if (!/^https?:\/\//i.test(finalUrl) || !/^\d{3}$/.test(status)) throw new Error('curl response metadata invalid')
+    return { text: out.slice(0, at), url: finalUrl, status: Number(status) }
   }
   // A failed proxy request is a provider failure. Do not silently bypass the
   // configured proxy or send a second copy of a potentially billable POST.
-  return requestText(url, { ...options, proxy, timeoutMs })
+  const result = await requestTextInfo(url, { ...options, proxy, timeoutMs })
+  return wantInfo ? result : result.text
 }
 
 async function curlGet(url, timeoutMs = 25000) {
   return httpFetch(url, { method: 'GET' }, timeoutMs)
 }
 
+async function curlGetInfo(url, timeoutMs = 25000) {
+  return httpFetch(url, { method: 'GET' }, timeoutMs, true)
+}
+
 async function curlPostForm(url, form, timeoutMs = 25000) {
   return httpFetch(url, {
     method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: form,
@@ -405,13 +421,17 @@ async function viaGoogle(text, to) {
 
 async function bingSession() {
   if (bingCache !== null && Date.now() < bingCache.exp) return bingCache
-  const html = await curlGet('https://www.bing.com/translator')
+  const page = await curlGetInfo('https://www.bing.com/translator')
+  const html = page.text
   const ig = html.match(/IG:"([^"]+)"/)
   const ab = html.match(/params_AbusePreventionHelper\s*=\s*\[([^\]]*)\]/)
   if (!ig || !ab) throw new Error('bing page shape changed')
   const parts = ab[1].split(',').map(function (s) { return s.trim().replace(/^"/, '').replace(/"$/, '') })
   if (parts.length < 2 || !parts[0] || !parts[1]) throw new Error('bing params empty')
-  bingCache = { ig: ig[1], key: parts[0], token: parts[1], exp: Date.now() + 50 * 60 * 1000 }
+  const translator = html.match(/<[^>]*\bid\s*=\s*["']rich_tta["'][^>]*>/i)
+  const iid = translator && translator[0].match(/\bdata-iid\s*=\s*["']([^"']+)["']/i)
+  bingCache = { ig: ig[1], key: parts[0], token: parts[1],
+    origin: new URL(page.url).origin, iid: iid ? iid[1] : 'SERP', exp: Date.now() + 50 * 60 * 1000 }
   return bingCache
 }
 
@@ -425,12 +445,12 @@ function bingTarget(to) {
 async function viaBing(text, to) {
   const s = await bingSession()
   const form = 'fromLang=auto-detect&text=' + encodeURIComponent(text) + '&to=' + encodeURIComponent(bingTarget(to)) + '&token=' + encodeURIComponent(s.token) + '&key=' + encodeURIComponent(s.key)
-  // The current translator page builds /ttranslatev3?isVertical=1 (the old
-  // isIntl=1 param is gone); curlPostForm follows redirects (-L), so CN users
-  // get auto-redirected www.bing.com -> cn.bing.com while the rest of the
-  // world stays on www.bing.com.
-  const raw = await curlPostForm('https://www.bing.com/ttranslatev3?isVertical=1&IG=' + encodeURIComponent(s.ig) + '&IID=SERP', form)
-  const arr = JSON.parse(raw)
+  // CN networks redirect the session page to cn.bing.com. Post back to that
+  // origin: following a 302 on the POST itself would discard the form body.
+  const raw = await curlPostForm(s.origin + '/ttranslatev3?isVertical=1&IG=' + encodeURIComponent(s.ig) + '&IID=' + encodeURIComponent(s.iid), form)
+  if (!raw || !raw.trim()) throw new Error('bing empty response')
+  let arr
+  try { arr = JSON.parse(raw) } catch { throw new Error('bing non-JSON response') }
   if (!Array.isArray(arr) && arr && arr.statusCode) throw new Error('bing API ' + arr.statusCode + ': ' + (arr.errorMessage || 'request rejected'))
   const tr = Array.isArray(arr) && arr[0] && arr[0].translations && arr[0].translations[0]
   if (!tr || typeof tr.text !== 'string' || !tr.text.trim()) throw new Error('bing empty translation')
@@ -951,9 +971,7 @@ function isCodeOnlyLine(line) {
   return /^(?:[$>#]\s*)?(?:(?:npm|pnpm|yarn|bun|npx|node|git|cd|curl|pwsh|reg)\b|(?:const|let|var|import|export|function|class|return|if|for|while|async|await)\b|[\[{(]|['"]?[\w.-]+['"]?\s*(?:[:=]|=>)|[\w$.]+\s*\(|(?:[~./][\w@~./-]*|[\w.-]+\/[\w@~./-]+)(?::\d+)?$)/.test(line)
 }
 function hasProse(text) {
-  const outside = text
-    .replace(/```[\s\S]*?```/g, ' ')
-    .replace(/`[^`\n]*`/g, ' ')
+  const outside = protectedTextParts(text).filter(part => !part.code).map(part => part.text).join(' ')
     .replace(/https?:\/\/\S+/g, ' ')
   const lines = outside.split('\n').map(function (l) { return l.trim() }).filter(Boolean)
   if (lines.length === 0) return false
@@ -963,7 +981,7 @@ function hasProse(text) {
 }
 // Decide from prose, not paths, identifiers, or structured payloads (#10).
 function proseForDetection(text) {
-  let prose = text.replace(/```[\s\S]*?```/g, ' ').replace(/`[^`\n]*`/g, ' ')
+  let prose = protectedTextParts(text).filter(part => !part.code).map(part => part.text).join(' ')
     .replace(/https?:\/\/[^\s<>]+/g, ' ')
     .replace(/\b[A-Za-z]:[\\/][^\s"'`,;，。；！？、)}\]]*/g, ' ')
     .replace(/(^|\s)\/(?:[^\s"'`,;，。；！？、)}\]]+)/g, '$1 ')
@@ -1038,15 +1056,13 @@ async function runChainFor(ids, text, target, cfg) {
     if (!adapter) continue
     try {
       if (ollamaOrigin(id, p)) await localPreparation.ensure(p)
-      const chunks = chunkText(text)
-      const outs = []
-      for (const c of chunks) outs.push(await adapter(c, target, p))
+      const translated = await translateProtectedText(text, chunk => adapter(chunk, target, p), chunkText)
       state.ok++
       state.lastProvider = id
       state.lastError = null
       // Carry the concrete model name so the UI can show e.g. "openai: qwen2.5:14b".
       attempts.push({ provider: id, signature: providerFingerprint(p), ok: true, model: p.model || null })
-      return { ok: true, text: outs.join('\n\n'), provider: id, providerSignature: providerFingerprint(p), attempts, ...(p.model ? { model: p.model } : {}) }
+      return { ok: true, text: translated, provider: id, providerSignature: providerFingerprint(p), attempts, ...(p.model ? { model: p.model } : {}) }
     } catch (e) {
       lastErr = e
       attempts.push({ provider: id, signature: providerFingerprint(p), ok: false, model: p.model || null })
@@ -1098,7 +1114,7 @@ async function handleTranslate(body) {
       if (!adapter) return { ok: false, text, error: 'unsupported type: ' + p.type }
       try {
         if (ollamaOrigin(forced, p)) await localPreparation.ensure(p)
-        const out = await adapter(text, target, p)
+        const out = await translateProtectedText(text, chunk => adapter(chunk, target, p), chunkText)
         return { ok: true, text: out, provider: forced, providerSignature: providerFingerprint(p), ...(p.model ? { model: p.model } : {}) }
       } catch (e) {
         return { ok: false, text, error: e instanceof Error ? e.message : String(e) }

package/lib/text.js

@@ -0,0 +1,77 @@
+// Code spans keep their exact source offsets so neither translation nor batching
+// needs placeholders that a provider could translate, remove, or reorder.
+export function protectedTextParts(text) {
+  const parts = []
+  let proseStart = 0
+  let cursor = 0
+  function protect(start, end, complete) {
+    if (start > proseStart) parts.push({ text: text.slice(proseStart, start), start: proseStart, end: start, code: false, complete: true })
+    parts.push({ text: text.slice(start, end), start, end, code: true, complete })
+    proseStart = end
+    cursor = end
+  }
+  function lineEnd(start) {
+    const newline = text.indexOf('\n', start)
+    return newline < 0 ? text.length : newline + 1
+  }
+  while (cursor < text.length) {
+    if (cursor === 0 || text[cursor - 1] === '\n') {
+      const end = lineEnd(cursor)
+      const line = text.slice(cursor, end)
+      // Treat indented/quoted fences conservatively as code as well.
+      const fence = line.match(/^[\t ]*(?:>[\t ]*)*(?:(?:[-+*]|[0-9]+[.)])[\t ]+)?(`{3,}|~{3,})[^\r\n]*(?:\r?\n)?$/)
+      if (fence) {
+        const close = new RegExp('^[\\t ]*(?:>[\\t ]*)*' + fence[1][0] + '{' + fence[1].length + ',}[\\t ]*(?:\\r?\\n)?$')
+        let stop = end
+        let complete = false
+        while (stop < text.length) {
+          const next = lineEnd(stop)
+          if (close.test(text.slice(stop, next))) { stop = next; complete = true; break }
+          stop = next
+        }
+        protect(cursor, stop, complete)
+        continue
+      }
+      if (/^(?: {4}|\t)/.test(line)) {
+        protect(cursor, end, end < text.length || line.endsWith('\n'))
+        continue
+      }
+    }
+    if (text[cursor] === '`') {
+      let slashes = 0
+      for (let i = cursor - 1; i >= 0 && text[i] === '\\'; i--) slashes++
+      if (slashes % 2) { cursor++; continue }
+      let after = cursor + 1
+      while (text[after] === '`') after++
+      const size = after - cursor
+      let next = after
+      let stop = text.length
+      let complete = false
+      while ((next = text.indexOf('`', next)) >= 0) {
+        let end = next + 1
+        while (text[end] === '`') end++
+        if (end - next === size) { stop = end; complete = true; break }
+        next = end
+      }
+      // An unfinished streaming code span must not expose its body as prose.
+      protect(cursor, stop, complete)
+      continue
+    }
+    cursor++
+  }
+  if (proseStart < text.length) parts.push({ text: text.slice(proseStart), start: proseStart, end: text.length, code: false, complete: true })
+  return parts
+}
+
+// Only prose reaches a provider; separators adjoining code stay byte-for-byte.
+export async function translateProtectedText(text, translate, split = value => [value]) {
+  const output = []
+  for (const part of protectedTextParts(text)) {
+    const match = !part.code && part.text.match(/^(\s*)([\s\S]*?)(\s*)$/)
+    if (!match || !/\p{L}/u.test(match[2])) { output.push(part.text); continue }
+    const chunks = []
+    for (const chunk of split(match[2])) chunks.push((await translate(chunk)).trim())
+    output.push(match[1] + chunks.join('\n\n') + match[3])
+  }
+  return output.join('')
+}

package/lib/transport.js

@@ -3,6 +3,11 @@ import https from 'node:https'
 import tls from 'node:tls'
 import { isIP } from 'node:net'
 
+export const DEFAULT_HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
+  Accept: 'application/json,text/plain,*/*',
+}
+
 export function isLoopback(url) {
   const host = new URL(url).hostname.replace(/^\[|\]$/g, '').toLowerCase()
   return ['localhost', '127.0.0.1', '::1', '::ffff:7f00:1'].includes(host)
@@ -101,11 +106,12 @@ function requestOnce(url, options) {
   })
 }
 
-export async function requestText(urlString, options = {}) {
+// Report the final URL so session-based callers can post back to the origin
+// that served their page instead of redirecting a POST and losing its body.
+export async function requestTextInfo(urlString, options = {}) {
   let url = new URL(urlString)
   let method = options.method || 'GET', body = options.body
-  let headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
-    Accept: 'application/json,text/plain,*/*', ...options.headers }
+  let headers = { ...DEFAULT_HEADERS, ...options.headers }
   const deadline = Date.now() + (options.timeoutMs || 25000)
   for (let redirects = 0; redirects <= 5; redirects++) {
     if (!['http:', 'https:'].includes(url.protocol)) throw new Error('Unsupported request protocol: ' + url.protocol)
@@ -130,6 +136,10 @@ export async function requestText(urlString, options = {}) {
       continue
     }
     if (response.status < 200 || response.status >= 300) throw new Error('HTTP ' + response.status)
-    return response.text
+    return { text: response.text, url: url.href, status: response.status }
   }
 }
+
+export async function requestText(urlString, options = {}) {
+  return (await requestTextInfo(urlString, options)).text
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-think-translate",
   "description": "Display-layer translation for the DSH web app: thinking chain, task cards, and optional answer text, in 8 target languages (local Ollama / any OpenAI-compatible or Anthropic endpoint / Google / Bing, fail-open)",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -15,6 +15,7 @@
     "lib/ollama.js",
     "lib/transport.js",
     "lib/discovery.js",
+    "lib/text.js",
     "cordis.patch.yml",
     "demo/demo.gif",
     "demo/demo2.gif"