claude-translator 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] — 2026-08-25
+
+### Changed
+
+- **The `openai` adapter's default model is now `gpt-5.6-luna`**, replacing `gpt-4o-mini`.
+  OpenAI has not published a shutdown date for `gpt-4o-mini`, but the rest of that generation
+  has one — `gpt-4o-2024-05-13`, `o1`, `o3-mini` and `gpt-4.1-nano` all retire 2026-10-23 — and
+  a 2024 model is no longer a sensible default for new projects. Anyone pinning `gpt-4o-mini` in
+  `i18n.config.json` is unaffected
+
+- **Reasoning models no longer receive `temperature`.** This was a required change, not a
+  cosmetic one: `gpt-5.6-luna` rejects any temperature but `1`, so the model swap alone would
+  have returned `400 Unsupported value: 'temperature' does not support 0.2 with this model` on
+  every single request. Model ids matching `^gpt-5` or `^o[1-9]` now get no sampling parameter
+  and `reasoning_effort: 'none'` instead — bulk segment translation is a low-reasoning task, the
+  same argument `anthropic.mjs` makes when it pins its thinking tiers to `effort: 'low'`.
+  The match is anchored, so a local model whose id merely contains `gpt-5` keeps `temperature`
+
+### Added
+
+- **Automatic recovery from an unsupported request parameter.** A new optional adapter hook,
+  `unsupportedParam(status, errText)`, names one parameter the server rejected; `translate.mjs`
+  drops it and retries, exactly as it already steps down the `response_format` ladder. Each
+  parameter is dropped at most once, so it cannot loop. This is the general form of the bug
+  above — the next reasoning model with a new restriction now degrades instead of failing a run
+
+  The hook is deliberately hard to trigger: the error must read as a capability complaint *and*
+  name a parameter the adapter actually sends. A plain `400 model not found` is still a failure,
+  because an adapter that quietly strips its own request is worse than one that stops
+
+- Seven contract tests covering the reasoning-model rule, the `gpt-4o-mini` regression, local
+  model ids, the `drop` set, and `unsupportedParam` — including that it and `unsupportedJsonMode`
+  never both claim the same error. 39 tests total
+
+### Verified
+
+- `gpt-5.6-luna` translated the same 98-unit site into Russian live: 3,450 / 2,876 tokens,
+  **0 failed units**, six of six gates, 0 SEO findings, and no fallback needed — the proactive
+  rule was correct up front. Its output shares only 21% of units with the `gpt-4o-mini` run,
+  confirming the new default actually took effect. `unsupportedParam` was separately checked
+  against a real 400 from the live API rather than a paraphrase of one. The Anthropic and Gemini
+  adapters were re-run unchanged to confirm the `translate.mjs` change disturbed neither
+
 ## [1.3.0] — 2026-08-25
 
 ### Added
@@ -28,6 +71,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `package.json` gained a `files` allowlist, so the tarball carries the scripts,
   references, `SKILL.md` and the example config, and nothing else
 
+### Verified
+
+- **All three provider adapters called for real, for the first time** (2026-08-25). Until now
+  every adapter had only ever been exercised by the offline contract tests in
+  `scripts/providers/providers.test.mjs` — which prove the request we *build*, and cannot prove
+  the request a server *accepts*. Each adapter translated the same 98-unit, 1,381-word site into
+  Russian at its shipped default model, with `i18n/tm/ru.json` deleted between runs so that no
+  provider could silently reuse another's translations and report a success without calling
+  anything:
+
+  | Adapter | Model | Tokens in/out | Cost | Failed units | Gates | SEO audit |
+  | --- | --- | --- | --- | --- | --- | --- |
+  | `anthropic` | `claude-haiku-4-5` | 4,315 / 4,130 | $0.025 | 0 | 6/6 | 0 findings |
+  | `gemini` | `gemini-2.5-flash-lite` | 3,412 / 3,611 | $0.002 | 0 | 6/6 | 0 findings |
+  | `openai` | `gpt-4o-mini` | 3,453 / 2,855 | not priced by design | 0 | 6/6 | 0 findings |
+
+  All three passed on the first attempt and no adapter needed changing. Specifically confirmed
+  live: Anthropic's `output_config.format` structured-output shape is accepted and Haiku 4.5
+  correctly receives `temperature` and no `effort`; both non-default model ids still exist; and
+  Cyrillic round-trips with every `<0>…</0>` placeholder intact across the 12 units that carry
+  inline markup, with the `doNotTranslate` glossary holding the brand name in all 10 units
+  containing it.
+
+  The README's provider table now carries a *last verified* date per adapter, so a retired model
+  id shows up as staleness rather than as a first-time user's unexplained 404.
+
 ## [1.2.0] — 2026-08-25
 
 Renamed to **Claude Translator**, and the translation step is no longer tied to one vendor.

package/README.md

@@ -276,16 +276,49 @@ purging is destructive and its heuristics have known blind spots.
 The translation step is the only part that talks to a model, and it talks through a small
 adapter. Three ship with the project, and anything else is one file.
 
-| `provider` | Default model | Key |
-| --- | --- | --- |
-| `anthropic` *(default)* | `claude-haiku-4-5` | `ANTHROPIC_API_KEY` |
-| `gemini` | `gemini-2.5-flash-lite` | `GEMINI_API_KEY` |
-| `openai` | `gpt-4o-mini` | `OPENAI_API_KEY` |
-| `./my-provider.mjs` | — | yours |
+| `provider` | Default model | Key | Last verified against the live API |
+| --- | --- | --- | --- |
+| `anthropic` *(default)* | `claude-haiku-4-5` | `ANTHROPIC_API_KEY` | 2026-08-25 |
+| `gemini` | `gemini-2.5-flash-lite` | `GEMINI_API_KEY` | 2026-08-25 |
+| `openai` | `gpt-5.6-luna` | `OPENAI_API_KEY` | 2026-08-25 |
+| `./my-provider.mjs` | — | yours | — |
 
 Omit `provider` and it is inferred from the model id, so configs written before 1.2 keep
 working unchanged.
 
+**What "verified" means in that last column.** On 2026-08-25 each of the three adapters
+translated the same 98-unit, 1,381-word English site into Russian at its default model, as a
+real billed API call, with the translation memory deleted between runs so no provider could
+reuse another's work. Every run cleared all six gates in `verify.mjs` and produced a clean
+`audit-seo.mjs` — 0 findings — and no run had a single failed unit. Measured cost: $0.025
+(Claude), $0.002 (Gemini), and 3,453/2,855 tokens on OpenAI, which the adapter deliberately
+does not price because it points at dozens of endpoints, some of them free and local.
+
+The three memories agreed on only 28–36% of units pairwise, and the ones all three agreed on
+were short labels like "Три плана". That divergence is the evidence the runs were independent.
+
+This column is a freshness marker, not a guarantee. Model ids get retired; if a default stops
+working, that is what this date is for. The contract tests in `scripts/providers/` still run
+on every commit with no network and no key — they catch a malformed request, not a rejected
+one.
+
+**Reasoning models and `temperature`.** The `openai` default is a reasoning model, and those
+reject sampling parameters — GPT-5.x answers a `temperature: 0.2` with
+`400 Unsupported value: 'temperature' … Only the default (1) value is supported`. The adapter
+handles this twice over: it omits `temperature` and sends `reasoning_effort: 'none'` for model
+ids it recognises as reasoning models, and if a server rejects a parameter anyway, the run drops
+that one parameter and retries instead of failing. A pinned `gpt-4o-mini`, and every local model,
+still get `temperature` exactly as before.
+
+`reasoning_effort` is `'none'` because bulk segment translation is a low-reasoning task — the
+same reason the Anthropic adapter pins its thinking tiers to `effort: 'low'`. Paying for a
+reasoning pass on every batch of forty segments is the one cost here worth engineering away.
+
+**Pricing.** `gpt-5.6-luna` is $0.20 in / $1.20 out per million tokens. The adapter reports no
+cost, deliberately — `pricing()` cannot see `baseUrl`, so it cannot tell OpenAI itself from
+OpenRouter or a local server offering the same model id. Set `pricing` in `i18n.config.json` to
+get a figure in the run summary.
+
 **The `openai` adapter is the interesting one**, because `/v1/chat/completions` is what
 everything speaks. That one adapter covers OpenAI, Azure, Groq, DeepSeek, Mistral,
 OpenRouter, Together and Fireworks — and Ollama, LM Studio and vLLM, which means the whole

package/SKILL.md

@@ -14,7 +14,7 @@ argument-hint: "[project-dir]"
 license: AGPL-3.0
 metadata:
   author: ConveyThis
-  version: "1.3.0"
+  version: "1.4.0"
   category: i18n
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-translator",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Translate a static website into dozens of languages as real static pages, by substituting into built HTML instead of re-rendering.",
   "type": "module",
   "license": "AGPL-3.0-or-later",

package/references/providers.md

@@ -18,7 +18,7 @@ talks through a small adapter. Three ship with the project; anything else is one
 | --- | --- | --- | --- |
 | `anthropic` | `claude-haiku-4-5` | `ANTHROPIC_API_KEY` | The default. |
 | `gemini` | `gemini-2.5-flash-lite` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | Roughly a tenth the cost — see [throughput-and-cost.md](throughput-and-cost.md). |
-| `openai` | `gpt-4o-mini` | `OPENAI_API_KEY` | Any OpenAI-compatible endpoint, including local ones. |
+| `openai` | `gpt-5.6-luna` | `OPENAI_API_KEY` | Any OpenAI-compatible endpoint, including local ones. |
 | `./my-provider.mjs` | — | yours | A path is imported directly. See below. |
 
 `--provider` and `--model` on the command line override the config for one run.
@@ -98,7 +98,7 @@ export const envKeys = ['MY_PROVIDER_KEY'];  // checked in order, env then .env
 export const keyOptional = false;            // true for local servers
 
 /** Build one HTTP request. */
-export function request({ model, system, items, temperature, key, baseUrl, jsonMode }) {
+export function request({ model, system, items, temperature, key, baseUrl, jsonMode, drop }) {
   return {
     url: `${baseUrl ?? 'https://api.example.com/v1'}/translate`,
     headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
@@ -121,6 +121,20 @@ export const unwrap = (parsed) => parsed.translations ?? parsed;
 
 /** Optional: USD per million tokens, [in, out]. Omit if unknown. */
 export function pricing(model) { return [0.5, 1.5]; }
+
+/**
+ * Optional: name ONE request parameter the server rejected, so translate.mjs can retry
+ * without it. Return null for anything else. The parameter is added to a `drop` set
+ * that is passed back into request(), and each one is dropped at most once.
+ *
+ * Set the bar high. The error must read as a capability complaint AND name a parameter
+ * you actually send; otherwise a genuine 400 gets mistaken for a recoverable one and the
+ * run quietly strips its own request instead of telling the user what is wrong.
+ */
+export function unsupportedParam(status, errText) {
+  if (status !== 400) return null;
+  return /unsupported.*\btemperature\b/i.test(errText) ? 'temperature' : null;
+}
 ```
 
 Then:

package/scripts/credit.mjs

@@ -32,7 +32,7 @@
 
 import { CREDIT } from './config.mjs';
 
-export const VERSION = '1.3.0';
+export const VERSION = '1.4.0';
 
 /**
  * The product name written into every localized page's generator tag.

package/scripts/providers/openai.mjs

@@ -22,18 +22,44 @@
  * so a weaker guarantee here costs retries, not correctness. The rung is chosen by
  * config (`jsonMode`) and falls back automatically when the server rejects a request
  * for mentioning `response_format`.
+ *
+ * ── Sampling is not universal either ─────────────────────────────────────────
+ * The same "one adapter, many servers" problem applies to `temperature`. Reasoning
+ * models reject it outright — GPT-5.x answers a `temperature: 0.2` with
+ * 400 "Unsupported value: 'temperature' … Only the default (1) is supported" — and
+ * they take a reasoning budget instead. That is handled twice over, deliberately:
+ * proactively by the model table below, and reactively by `unsupportedParam()`, so a
+ * model family nobody has heard of yet degrades instead of failing the whole run.
  */
 
 const API = 'https://api.openai.com/v1';
 
 export const id = 'openai';
 export const label = 'OpenAI-compatible';
-export const defaultModel = 'gpt-4o-mini';
+export const defaultModel = 'gpt-5.6-luna';
 export const envKeys = ['OPENAI_API_KEY', 'OPENAI_COMPATIBLE_API_KEY'];
 
 /** Local servers accept any key, but some reject a missing Authorization header. */
 export const keyOptional = true;
 
+/**
+ * Model families that reject sampling parameters and take `reasoning_effort` instead.
+ *
+ * Kept to a prefix match on purpose. This adapter points at dozens of servers, and a
+ * local model whose id merely CONTAINS "gpt-5" must not be caught by it — `qwen2.5:14b`
+ * and friends still get `temperature` exactly as before.
+ */
+const REASONING = [/^gpt-5/i, /^o[1-9](-|$)/i];
+const isReasoning = (model) => REASONING.some((re) => re.test(String(model)));
+
+/**
+ * Parameters this adapter is willing to drop and retry without. Nothing else is
+ * droppable, so a 400 that happens to contain the word "unsupported" can never make the
+ * pipeline silently discard something load-bearing. `response_format` is deliberately
+ * absent — it has its own ladder in `unsupportedJsonMode()`.
+ */
+const DROPPABLE = ['temperature', 'reasoning_effort', 'top_p'];
+
 const RESPONSE_SCHEMA = {
   type: 'object',
   properties: {
@@ -51,16 +77,28 @@ const RESPONSE_SCHEMA = {
   additionalProperties: false,
 };
 
-export function request({ model, system, items, temperature, key, baseUrl, jsonMode }) {
+export function request({ model, system, items, temperature, key, baseUrl, jsonMode, drop }) {
+  const dropped = drop ?? new Set();
   const body = {
     model,
-    temperature,
     messages: [
       { role: 'system', content: system },
       { role: 'user', content: JSON.stringify(items) },
     ],
   };
 
+  // Reasoning models: no sampling parameter, and no reasoning budget either. Bulk
+  // segment translation is a low-reasoning task, so paying for thinking tokens on every
+  // batch of forty is pure waste — the same call `anthropic.mjs` makes when it pins the
+  // thinking tiers to `effort: 'low'`. `temperature` is omitted rather than sent as 1 so
+  // the server applies its own default; sending a value it merely tolerates would be a
+  // claim we have no reason to make.
+  if (isReasoning(model)) {
+    if (!dropped.has('reasoning_effort')) body.reasoning_effort = 'none';
+  } else if (!dropped.has('temperature')) {
+    body.temperature = temperature;
+  }
+
   const mode = jsonMode ?? 'schema';
   if (mode === 'schema') {
     body.response_format = {
@@ -111,9 +149,31 @@ export const unwrap = (parsed) => parsed?.translations ?? parsed;
  */
 export function unsupportedJsonMode(status, errText) {
   if (status !== 400 && status !== 404 && status !== 422) return false;
+  if (unsupportedParam(status, errText)) return false; // a sampling complaint, not a schema one
   return /response_format|json_schema|json_object|not supported|unrecognized|unknown.*field/i.test(errText);
 }
 
+/**
+ * A rejection caused by ONE request parameter rather than by the request being wrong.
+ * Returns the parameter's name so `translate.mjs` can retry without it, or null.
+ *
+ * The bar is deliberately high: the error must read like a capability complaint AND name
+ * a parameter this adapter actually sends and is willing to lose. Anything looser would
+ * let a genuine 400 ("model not found") be mistaken for a recoverable one, and the run
+ * would keep quietly degrading its own request instead of telling the user.
+ *
+ * Real messages this must catch:
+ *   400 "Unsupported value: 'temperature' does not support 0.2 with this model.
+ *        Only the default (1) is supported."
+ *   400 "Unrecognized request argument supplied: reasoning_effort"
+ */
+export function unsupportedParam(status, errText) {
+  if (status !== 400 && status !== 422) return null;
+  const text = String(errText ?? '');
+  if (!/unsupported|unrecognized|unknown|not supported|does not support/i.test(text)) return null;
+  return DROPPABLE.find((p) => new RegExp(`\\b${p}\\b`).test(text)) ?? null;
+}
+
 /** Unknown by design: this adapter points at dozens of providers, and local ones are free. */
 export function pricing() {
   return null;

package/scripts/providers/providers.test.mjs

@@ -131,6 +131,86 @@ test('openai: default host and bearer auth', () => {
   assert.equal(r.body.messages[1].content, JSON.stringify(ITEMS));
 });
 
+// ── Reasoning models reject sampling ─────────────────────────────────────────
+// GPT-5.x answers `temperature: 0.2` with a 400 and takes reasoning_effort instead.
+// Both halves are asserted: what the reasoning models get, and — just as important —
+// that nothing else changed for the models and local servers that were working.
+
+test('openai: a reasoning model gets no temperature and no reasoning budget', () => {
+  const r = openai.request({ ...ARGS, model: 'gpt-5.6-luna' });
+  assert.equal(r.body.temperature, undefined, 'GPT-5.x returns 400 on any temperature but 1');
+  assert.equal(r.body.reasoning_effort, 'none', 'bulk translation must not pay for reasoning');
+});
+
+test('openai: the o-series is treated the same way', () => {
+  for (const model of ['o1', 'o3-mini', 'o4-mini']) {
+    const r = openai.request({ ...ARGS, model });
+    assert.equal(r.body.temperature, undefined, `${model} rejects sampling params`);
+    assert.equal(r.body.reasoning_effort, 'none');
+  }
+});
+
+test('openai: a pinned gpt-4o-mini still gets temperature, unchanged', () => {
+  const r = openai.request({ ...ARGS, model: 'gpt-4o-mini' });
+  assert.equal(r.body.temperature, 0.2);
+  assert.equal(r.body.reasoning_effort, undefined);
+});
+
+test('openai: a local model is never caught by the reasoning rule', () => {
+  // The match is anchored, so an id that merely CONTAINS "gpt-5" must not match —
+  // a local server would reject reasoning_effort and lose its sampling parameter.
+  for (const model of ['qwen2.5:14b', 'llama3.1:70b', 'my-finetune-of-gpt-5']) {
+    const r = openai.request({ ...ARGS, model });
+    assert.equal(r.body.temperature, 0.2, `${model} must keep sampling`);
+    assert.equal(r.body.reasoning_effort, undefined, `${model} must not be sent a reasoning budget`);
+  }
+});
+
+test('openai: request honours an explicit drop set', () => {
+  const noTemp = openai.request({ ...ARGS, model: 'gpt-4o-mini', drop: new Set(['temperature']) });
+  assert.equal(noTemp.body.temperature, undefined);
+
+  const noEffort = openai.request({ ...ARGS, model: 'gpt-5.6-luna', drop: new Set(['reasoning_effort']) });
+  assert.equal(noEffort.body.reasoning_effort, undefined);
+  assert.equal(noEffort.body.temperature, undefined, 'dropping the budget must not re-add sampling');
+});
+
+test('openai: unsupportedParam names the one parameter to drop', () => {
+  // The messages OpenAI actually returns.
+  assert.equal(
+    // Copied verbatim from a real 400 returned by gpt-5.6-luna on 2026-08-25.
+    openai.unsupportedParam(400, "Unsupported value: 'temperature' does not support 0.2 with this model. Only the default (1) value is supported."),
+    'temperature'
+  );
+  assert.equal(
+    openai.unsupportedParam(400, 'Unrecognized request argument supplied: reasoning_effort'),
+    'reasoning_effort'
+  );
+
+  // A genuine bad request must NOT be mistaken for a recoverable one, or the pipeline
+  // would quietly strip its own parameters instead of surfacing the real problem.
+  assert.equal(openai.unsupportedParam(400, 'model not found'), null);
+  assert.equal(openai.unsupportedParam(401, 'invalid api key'), null);
+  assert.equal(openai.unsupportedParam(429, 'rate limited'), null);
+  // Names a parameter we never send, so there is nothing to usefully drop.
+  assert.equal(openai.unsupportedParam(400, "Unsupported parameter: 'frequency_penalty'"), null);
+});
+
+test('openai: the two capability hooks never both claim the same error', () => {
+  const cases = [
+    "Unsupported value: 'temperature' does not support 0.2 with this model.",
+    'Unrecognized request argument supplied: reasoning_effort',
+    "Unknown field 'response_format'",
+    'json_schema is not supported',
+  ];
+  for (const text of cases) {
+    const json = openai.unsupportedJsonMode(400, text);
+    const param = openai.unsupportedParam(400, text);
+    assert.ok(!(json && param), `both hooks claimed: ${text}`);
+    assert.ok(json || param, `neither hook claimed a capability error: ${text}`);
+  }
+});
+
 test('openai: a custom host is used verbatim — this is how local models work', () => {
   const r = openai.request({ ...ARGS, model: 'qwen2.5:14b', baseUrl: 'http://localhost:11434/v1' });
   assert.equal(r.url, 'http://localhost:11434/v1/chat/completions');

package/scripts/translate.mjs

@@ -180,7 +180,7 @@ function validate(source, translated) {
  * `usage` is normalised to { inTok, outTok } so the caller never sees a provider's
  * own field names.
  */
-async function callModel(langCode, items, attempt = 1, jsonMode = JSON_MODE) {
+async function callModel(langCode, items, attempt = 1, jsonMode = JSON_MODE, drop = new Set()) {
   const { url, headers, body } = PROVIDER.request({
     model: MODEL,
     system: systemPrompt(langCode),
@@ -189,14 +189,15 @@ async function callModel(langCode, items, attempt = 1, jsonMode = JSON_MODE) {
     key: KEY,
     baseUrl: API_BASE_URL,
     jsonMode,
+    drop,
   });
 
   const split = async (why, mode = jsonMode) => {
     const mid = Math.ceil(items.length / 2);
     process.stderr.write(`  ${why} on ${items.length} units — splitting\n`);
     const [a, b] = await Promise.all([
-      callModel(langCode, items.slice(0, mid), 1, mode),
-      callModel(langCode, items.slice(mid), 1, mode),
+      callModel(langCode, items.slice(0, mid), 1, mode, drop),
+      callModel(langCode, items.slice(mid), 1, mode, drop),
     ]);
     return {
       rows: [...a.rows, ...b.rows],
@@ -219,7 +220,7 @@ async function callModel(langCode, items, attempt = 1, jsonMode = JSON_MODE) {
         `  network error (${String(err.message ?? err).slice(0, 60)}), retry ${attempt} in ${wait}ms\n`
       );
       await new Promise((r) => setTimeout(r, wait));
-      return callModel(langCode, items, attempt + 1, jsonMode);
+      return callModel(langCode, items, attempt + 1, jsonMode, drop);
     }
     throw err;
   }
@@ -236,16 +237,26 @@ async function callModel(langCode, items, attempt = 1, jsonMode = JSON_MODE) {
         process.stderr.write(
           `  server rejected JSON mode "${jsonMode ?? 'schema'}" — retrying with "${next}"\n`
         );
-        return callModel(langCode, items, attempt, next);
+        return callModel(langCode, items, attempt, next, drop);
       }
     }
 
+    // The same idea one level down: a server that rejects ONE parameter is telling us
+    // about its capabilities, not about a broken run. Drop that parameter and retry.
+    // `drop` only ever grows, so each parameter is dropped at most once and this cannot
+    // loop. Adapters that do not implement the hook are unaffected.
+    const bad = PROVIDER.unsupportedParam?.(res.status, text);
+    if (bad && !drop.has(bad)) {
+      process.stderr.write(`  server rejected "${bad}" — retrying without it\n`);
+      return callModel(langCode, items, attempt, jsonMode, new Set(drop).add(bad));
+    }
+
     const retryable = res.status === 429 || res.status >= 500;
     if (retryable && attempt <= 5) {
       const wait = Math.min(2 ** attempt * 1000, 30000);
       process.stderr.write(`  HTTP ${res.status}, retry ${attempt} in ${wait}ms\n`);
       await new Promise((r) => setTimeout(r, wait));
-      return callModel(langCode, items, attempt + 1, jsonMode);
+      return callModel(langCode, items, attempt + 1, jsonMode, drop);
     }
     throw new Error(`${PROVIDER.label ?? PROVIDER.id} HTTP ${res.status}: ${text.slice(0, 300)}`);
   }