llm-switcher 1.6.0 → 1.6.2

package/formats.mjs

@@ -311,6 +311,8 @@ const OPENAI_CHAT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high']);
 // Gemini's own ceiling for thinkingBudget. Above it the request is refused, not trimmed.
 const GEMINI_MAX_BUDGET = 32768;
 
+export const ANTHROPIC_EFFORT_LEVELS = ['low', 'medium', 'high', 'max'];
+
 function effortRank(e) {
   const i = EFFORT_LEVELS.indexOf(String(e || '').toLowerCase());
   return i;
@@ -322,24 +324,46 @@ function effortRank(e) {
  * ladder names, and a caller reads it as thinking off.
  */
 function normalizeEffort(e) {
-  const s = String(e || '').toLowerCase();
+  const s = String(e || '').toLowerCase().trim();
+  if (s === 'extra-low') return 'minimal';
   return effortRank(s) >= 0 ? s : 'medium';
 }
 
 /**
- * The level a target accepts: the one asked for, or the top of `allowed` when the target names
- * fewer levels than the ladder does. Never silently drops below what was asked for.
+ * Maps an effort level to the closest equivalent supported by the target.
+ * - Exact match if supported.
+ * - If target has fewer levels, chooses the closest matching depth (prefers floor for higher, ceil for lower).
  */
-function capEffort(e, allowed) {
+export function mapEquivalentEffort(e, allowed) {
   const wanted = normalizeEffort(e);
-  if (!Array.isArray(allowed) || !allowed.length || allowed.includes(wanted)) return wanted;
+  if (!Array.isArray(allowed) || !allowed.length) return wanted;
+  if (allowed.includes(wanted)) return wanted;
+
+  const wantedRank = effortRank(wanted);
   let best = allowed[0];
+  let bestDist = Math.abs(effortRank(best) - wantedRank);
+
   for (const a of allowed) {
-    if (effortRank(a) >= 0 && effortRank(a) <= effortRank(wanted) && effortRank(a) > effortRank(best)) best = a;
+    const r = effortRank(a);
+    if (r < 0) continue;
+    const dist = Math.abs(r - wantedRank);
+    // Choose the level closest in rank. On a tie, prefer the higher level to preserve reasoning capacity.
+    if (dist < bestDist || (dist === bestDist && r > effortRank(best))) {
+      best = a;
+      bestDist = dist;
+    }
   }
   return best;
 }
 
+/**
+ * The level a target accepts: the one asked for, or the closest equivalent in `allowed`
+ * when the target names fewer levels than the ladder does.
+ */
+function capEffort(e, allowed) {
+  return mapEquivalentEffort(e, allowed);
+}
+
 /**
  * The level a token budget stands for: the highest whose budget the number reaches. An exact
  * effortToEffort round trip returns the level that was asked for.
@@ -976,12 +1000,17 @@ function healToolPairs(messages) {
   return out;
 }
 
-export const THINKING_MODES = ['auto', 'native', 'off'];
+const THINKING_MODES = ['auto', 'native', 'off'];
+const VALID_EFFORTS = ['auto', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
 
 function normThinkingMode(mode) {
   return THINKING_MODES.includes(mode) ? mode : 'auto';
 }
 
+function normThinkingEffort(effort) {
+  return typeof effort === 'string' && VALID_EFFORTS.includes(effort.toLowerCase()) ? effort.toLowerCase() : 'auto';
+}
+
 // IR -> OpenAI Chat Completions body.
 //
 // opts.thinkingMode (per profile):
@@ -1071,14 +1100,25 @@ function irToChatBody(ir, model, opts = {}) {
     body.response_format = { type: 'json_object' };
   }
 
+  const effortOverride = normThinkingEffort(opts.thinkingEffort);
   if (wantsThinking && mode === 'native') {
     // A strict OpenAI upstream names four levels and refuses the rest, so `xhigh` becomes `high`
     // there and not `medium`: the request keeps as much of the depth as the target can take.
-    const asked = ir.thinking?.effort
-      || (ir.thinking?.type === 'adaptive' ? 'high' : (ir.thinking?.budget ? budgetToEffort(ir.thinking.budget) : 'medium'));
-    body.reasoning_effort = capEffort(asked, OPENAI_CHAT_LEVELS);
+    const asked = effortOverride !== 'auto'
+      ? effortOverride
+      : (ir.thinking?.effort || (ir.thinking?.type === 'adaptive' ? 'high' : (ir.thinking?.budget ? budgetToEffort(ir.thinking.budget) : 'medium')));
+    if (asked !== 'none') {
+      body.reasoning_effort = capEffort(asked, OPENAI_CHAT_LEVELS);
+    }
   } else if (wantsThinking) {
-    if (ir.thinking?.type === 'adaptive') {
+    if (effortOverride !== 'auto') {
+      if (effortOverride !== 'none') {
+        const rawBudget = effortToBudget(effortOverride);
+        const safeBudget = clampBudget(rawBudget);
+        body.thinking = { type: 'enabled', budget_tokens: safeBudget };
+        body.reasoning_effort = normalizeEffort(effortOverride);
+      }
+    } else if (ir.thinking?.type === 'adaptive') {
       body.thinking = { type: 'adaptive' };
       body.reasoning_effort = normalizeEffort(ir.thinking.effort || 'high');
     } else {
@@ -1122,7 +1162,7 @@ function contentToAnthropicBlocks(c) {
 }
 
 // IR -> Anthropic Messages body.
-function irToAnthropicBody(ir, model) {
+function irToAnthropicBody(ir, model, opts = {}) {
   const messages = [];
 
   for (const m of healToolPairs(ir.messages)) {
@@ -1202,15 +1242,26 @@ function irToAnthropicBody(ir, model) {
   // level Anthropic names, so the depth survives the hop instead of becoming a number. A client
   // that sent budget_tokens has already said the same thing in Anthropic's own words, and its
   // budget stands: budget and effort together would be the same request twice.
-  if (ir.thinking && ir.thinking.type !== 'disabled' && ir.thinking.effort && !ir.thinking.budget) {
-    body.output_config = { ...(body.output_config || {}), effort: capEffort(ir.thinking.effort, EFFORT_LEVELS) };
-  }
-  if (ir.thinking && ir.thinking.type === 'adaptive') {
-    body.thinking = { type: 'adaptive' };
-  } else if (ir.thinking && ir.thinking.type !== 'disabled' && body.max_tokens > 1024) {
-    // Anthropic requires 1024 <= budget_tokens < max_tokens; drop thinking when max_tokens is too small.
-    const budget = clampBudget(ir.thinking.budget ?? (ir.thinking.effort ? effortToBudget(ir.thinking.effort) : 4096));
-    body.thinking = { type: 'enabled', budget_tokens: Math.min(budget, body.max_tokens - 1) };
+  const effortOverride = normThinkingEffort(opts.thinkingEffort);
+  if (effortOverride !== 'auto') {
+    if (effortOverride !== 'none') {
+      body.output_config = { ...(body.output_config || {}), effort: capEffort(effortOverride, EFFORT_LEVELS) };
+      if (body.max_tokens > 1024) {
+        const budget = clampBudget(effortToBudget(effortOverride));
+        body.thinking = { type: 'enabled', budget_tokens: Math.min(budget, body.max_tokens - 1) };
+      }
+    }
+  } else {
+    if (ir.thinking && ir.thinking.type !== 'disabled' && ir.thinking.effort && !ir.thinking.budget) {
+      body.output_config = { ...(body.output_config || {}), effort: capEffort(ir.thinking.effort, EFFORT_LEVELS) };
+    }
+    if (ir.thinking && ir.thinking.type === 'adaptive') {
+      body.thinking = { type: 'adaptive' };
+    } else if (ir.thinking && ir.thinking.type !== 'disabled' && body.max_tokens > 1024) {
+      // Anthropic requires 1024 <= budget_tokens < max_tokens; drop thinking when max_tokens is too small.
+      const budget = clampBudget(ir.thinking.budget ?? (ir.thinking.effort ? effortToBudget(ir.thinking.effort) : 4096));
+      body.thinking = { type: 'enabled', budget_tokens: Math.min(budget, body.max_tokens - 1) };
+    }
   }
   if (body.thinking) {
     // When thinking is on, Anthropic rejects temperature != 1, top_k, or top_p < 0.95.
@@ -1232,7 +1283,7 @@ function dataUrlToInlineData(url) {
 }
 
 // IR -> Vertex generateContent body.
-function irToVertexBody(ir, model) {
+function irToVertexBody(ir, model, opts = {}) {
   const contents = [];
   const textPartsOf = (c) => {
     if (typeof c === 'string') return c ? [{ text: c }] : [];
@@ -1320,7 +1371,15 @@ function irToVertexBody(ir, model) {
   if (typeof ir.params.topK === 'number') gc.topK = ir.params.topK;
   if (typeof ir.params.maxTokens === 'number') gc.maxOutputTokens = ir.params.maxTokens;
   if (ir.params.stop.length) gc.stopSequences = ir.params.stop;
-  if (ir.thinking && ir.thinking.type !== 'disabled') {
+  const effortOverride = normThinkingEffort(opts.thinkingEffort);
+  if (effortOverride !== 'auto') {
+    if (effortOverride !== 'none') {
+      gc.thinkingConfig = {
+        includeThoughts: true,
+        thinkingBudget: Math.min(clampBudget(effortToBudget(effortOverride)), GEMINI_MAX_BUDGET)
+      };
+    }
+  } else if (ir.thinking && ir.thinking.type !== 'disabled') {
     // includeThoughts: without this flag Gemini won't return thought parts -> the client loses thinking.
     gc.thinkingConfig = { includeThoughts: true };
     if (ir.thinking.type === 'enabled') {
@@ -1465,8 +1524,8 @@ function emitUpstreamBody(outFormat, ir, model, opts = {}) {
   let src = normThinkingMode(opts.thinkingMode) === 'off' ? { ...ir, thinking: { type: 'disabled' } } : ir;
   if (isAntigravityModel(model) && src.system) src = { ...src, system: src.system.replace(BILLING_HEADER_RE, '') };
   switch (outFormat) {
-    case 'anthropic': return irToAnthropicBody(src, model);
-    case 'vertex': return irToVertexBody(src, model);
+    case 'anthropic': return irToAnthropicBody(src, model, opts);
+    case 'vertex': return irToVertexBody(src, model, opts);
     case 'openai-chat':
     default: return irToChatBody(src, model, opts);
   }
@@ -2529,6 +2588,7 @@ export {
   smartReasoning, smartText, smartToolCalls, smartUsage, smartFinish,
   firstChoice, smartDelta, sanitizeJsonSchema, toGeminiSchema, splitParts,
   budgetToEffort, effortToBudget, clampBudget, normalizeEffort, capEffort, parseArgs, stringifyArgs,
+  THINKING_MODES, VALID_EFFORTS,
   anthropicToIR, responsesToIR, codeAssistToIR, parseToIR,
   healToolPairs, healAnthropicPayload, rememberToolSignature, lookupToolSignature, estimateTokens, irToChatBody, irToAnthropicBody, irToVertexBody, emitUpstreamBody,
   normalizeUpstream, createUpstreamNormalizer, createCollector,

package/idlecache.mjs

@@ -0,0 +1,159 @@
+// Gateway-owned prefix cache. Client transcripts and databases are never opened here.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { conversationKey } from './idlecompact.mjs';
+
+const digest = value => crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const MAX_RECORD_BYTES = 2 * 1024 * 1024;
+const VERSION = 1;
+
+export function policyFingerprint(policy) {
+  return digest(policy);
+}
+
+export function compactCacheKey(clientFormat, req, payload, ir, profile, profileKey, policy) {
+  const session = conversationKey(clientFormat, req, ir);
+  if (!session) return '';
+  // Credentials influence scope but only the final digest is stored on disk.
+  return digest({ clientFormat, session, profileKey, profile,
+    principal: [req?.headers?.authorization || '', req?.headers?.['x-api-key'] || '',
+      req?.headers?.['x-llm-switcher-token'] || ''],
+    context: { model: payload.model, system: payload.system, instructions: payload.instructions,
+      tools: payload.tools, toolChoice: payload.tool_choice }, policy });
+}
+
+function validRecord(r, key) {
+  if (!r || r.version !== VERSION || r.key !== key || !Number.isFinite(r.seenAt) || r.seenAt < 0) return false;
+  const allowed = ['version', 'key', 'seenAt', 'prefixCount', 'prefixHash', 'replacement',
+    'replacementHash', 'generation', 'createdAt'];
+  if (Object.keys(r).some(field => !allowed.includes(field))) return false;
+  if (!('prefixCount' in r)) return Object.keys(r).every(field => ['version', 'key', 'seenAt'].includes(field));
+  return Number.isInteger(r.prefixCount) && r.prefixCount > 0 && r.prefixCount <= 100000 &&
+    /^[a-f0-9]{64}$/.test(r.prefixHash) && typeof r.generation === 'string' &&
+    /^[a-f0-9-]{36}$/.test(r.generation) && Array.isArray(r.replacement) &&
+    /^[a-f0-9]{64}$/.test(r.replacementHash) && digest(r.replacement) === r.replacementHash &&
+    r.replacement.length > 0 && r.replacement.length <= 100000 &&
+    r.replacement.every(item => item && typeof item === 'object' && !Array.isArray(item) &&
+      (typeof item.role === 'string' || typeof item.type === 'string')) &&
+    Number.isFinite(r.createdAt) && r.createdAt >= 0;
+}
+
+export class IdlePrefixCache {
+  constructor(stateDir, { now = () => Date.now(), onDiagnostic = () => {} } = {}) {
+    this.dir = path.join(stateDir, 'idle-compact');
+    this.now = now;
+    this.onDiagnostic = onDiagnostic;
+  }
+
+  diagnostic(code) {
+    try { this.onDiagnostic(code); } catch { /* diagnostics cannot fail a client turn */ }
+  }
+
+  file(key) {
+    if (!/^[a-f0-9]{64}$/.test(key)) throw new Error('invalid cache key');
+    return path.join(this.dir, `${key}.json`);
+  }
+
+  load(key, policy) {
+    try {
+      const dirStat = fs.lstatSync(this.dir);
+      if (!dirStat.isDirectory() || dirStat.isSymbolicLink()) throw new Error('invalid cache directory');
+      const file = this.file(key);
+      const stat = fs.lstatSync(file);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_RECORD_BYTES) throw new Error('invalid cache file');
+      const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (!validRecord(record, key)) throw new Error('invalid cache record');
+      if (this.now() - record.seenAt > policy.sessionLookbackHours * 3600000 ||
+          record.seenAt > this.now() + 60000 ||
+          ('createdAt' in record && (record.createdAt > this.now() + 60000 ||
+            this.now() - record.createdAt > policy.sessionLookbackHours * 3600000))) {
+        this.remove(key);
+        return null;
+      }
+      return record;
+    } catch (err) {
+      if (err.code !== 'ENOENT') { this.diagnostic('cache-read-failed'); this.remove(key); }
+      return null;
+    }
+  }
+
+  remove(key) {
+    try {
+      const stat = fs.lstatSync(this.dir);
+      if (stat.isDirectory() && !stat.isSymbolicLink()) fs.unlinkSync(this.file(key));
+    } catch { /* missing or unavailable is safe */ }
+  }
+
+  save(record, policy) {
+    let tmp;
+    try {
+      if (!validRecord(record, record.key)) throw new Error('invalid cache record');
+      const bytes = JSON.stringify(record);
+      if (Buffer.byteLength(bytes) > MAX_RECORD_BYTES) throw new Error('cache record too large');
+      fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+      const stat = fs.lstatSync(this.dir);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('invalid cache directory');
+      fs.chmodSync(this.dir, 0o700);
+      const file = this.file(record.key);
+      tmp = `${file}.${crypto.randomUUID()}.tmp`;
+      fs.writeFileSync(tmp, bytes, { flag: 'wx', mode: 0o600 });
+      fs.renameSync(tmp, file);
+      this.prune(policy);
+      return true;
+    } catch {
+      if (tmp) try { fs.unlinkSync(tmp); } catch { /* unavailable */ }
+      this.diagnostic('cache-write-failed');
+      return false;
+    }
+  }
+
+  prune(policy) {
+    // Expire records using the configured session lookback, without evicting live sessions.
+    try {
+      const stat = fs.lstatSync(this.dir);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('invalid cache directory');
+      for (const entry of fs.readdirSync(this.dir)) {
+        if (!/^[a-f0-9]{64}\.json$/.test(entry)) continue;
+        const key = entry.slice(0, -5);
+        this.load(key, policy);
+      }
+    } catch { this.diagnostic('cache-prune-failed'); }
+  }
+
+  matches(record, history) {
+    return Array.isArray(history) && history.length >= record.prefixCount &&
+      digest(history.slice(0, record.prefixCount)) === record.prefixHash;
+  }
+
+  /** Return the previous pause and a cached rewrite; exact original suffix is kept verbatim. */
+  visit(key, history, policy) {
+    if (!key || !Array.isArray(history)) return { idleMs: 0, history: null, record: null };
+    let record = this.load(key, policy);
+    const idleMs = record ? Math.max(0, this.now() - record.seenAt) : 0;
+    if (record?.prefixCount && !this.matches(record, history)) {
+      record = null;
+    }
+    const shortened = record?.prefixCount
+      ? [...record.replacement, ...history.slice(record.prefixCount)] : null;
+    const touched = { ...(record || { version: VERSION, key }), seenAt: this.now() };
+    if (!this.save(touched, policy)) return { idleMs: 0, history: null, record: null };
+    return { idleMs: record ? idleMs : 0, history: shortened, record: touched };
+  }
+
+  create(key, history, prefixCount, replacement, policy) {
+    const record = { version: VERSION, key, seenAt: this.now(), createdAt: this.now(),
+      prefixCount, prefixHash: digest(history.slice(0, prefixCount)), replacement,
+      replacementHash: digest(replacement),
+      generation: crypto.randomUUID() };
+    return this.save(record, policy) ? record : null;
+  }
+
+  /** A late summary can upgrade only the generation that asked for it. */
+  upgrade(key, generation, replacement, policy) {
+    const record = this.load(key, policy);
+    if (!record?.prefixCount || record.generation !== generation) return false;
+    return this.save({ ...record, replacement, replacementHash: digest(replacement),
+      generation: crypto.randomUUID() }, policy);
+  }
+}

package/idlecall.mjs

@@ -1,67 +1,59 @@
-// The summary call.
-//
-// One extra model call, made once, when a long conversation comes back after a pause. It is not
-// free and it is not fast, and both costs are the price of not paying for the history on every
-// turn of the new window.
-//
-// It is a separate call rather than a turn of the conversation because the answer serves two
-// readers with different needs: the person waiting for the answer to their own question, and the
-// agent that will read the summary next time. Folding them together would mean either the person
-// reads a summary instead of an answer, or the summary is a summary of a summary.
-//
-// The model it uses is a setting, and empty means the one this conversation is already talking
-// to. A cheaper model writes a cheaper summary and a worse one: the summary replaces the history,
-// so what it leaves out is gone. That is the reader's call to make, not this gateway's.
-
+// Optional, independently routed summary call. Empty model means no model is called.
 import { clampSummary, summaryMessages } from './idlecompact.mjs';
 
-/** Asks for the summary. Returns the text, or '' when nothing usable came back. */
-export async function askSummary({ ir, policy, profile, mappedModel, model, build, fetchImpl = fetch, timeoutMs = 180000 }) {
-  const msgs = summaryMessages(ir, policy);
-  if (!msgs.length) return '';
-
-  const ir2 = { ...ir, messages: msgs, stream: false, tools: [], toolChoice: null };
-  const { url, headers, upBody } = build(profile, model, ir2);
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), timeoutMs);
+export async function askSummary({ ir, policy, profile, model, build, fetchImpl = fetch,
+  timeoutMs = 30000, onDiagnostic = () => {} }) {
+  if (!policy?.model || !model) return '';
+  const report = (code, status) => { try { onDiagnostic({ code, ...(status ? { status } : {}) }); } catch {} };
+  let timer;
   try {
-    const res = await fetchImpl(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(upBody),
-      signal: ac.signal,
+    const messages = summaryMessages(ir, policy);
+    if (messages.length < 2) { report('summary-empty-input'); return ''; }
+    const ir2 = { ...ir, messages, model, stream: false, tools: [], toolChoice: null };
+    // Build and serialization are inside the failure boundary too: a bad route cannot reject
+    // the promise before the caller installs its error handler.
+    const { url, headers, upBody } = build(profile, model, ir2);
+    const body = JSON.stringify(upBody);
+    const ac = new AbortController();
+    const boundedTimeout = Number.isFinite(timeoutMs) ? Math.max(1, Math.min(180000, timeoutMs)) : 30000;
+    timer = setTimeout(() => ac.abort(), boundedTimeout);
+    // Race an abort as well: test doubles and nonstandard fetch implementations may ignore it.
+    const timedOut = new Promise((_, reject) => {
+      ac.signal.addEventListener('abort', () => {
+        const error = new Error('summary timeout'); error.name = 'AbortError'; reject(error);
+      }, { once: true });
     });
-    if (!res.ok) return '';
-    const raw = await res.text();
-    return clampSummary(answerText(raw, ir2), policy);
-  } catch {
-    // A summary that could not be produced is not a reason to fail the turn. The caller still
-    // shortens the request, because a shortened history is worth having even with nothing
-    // written to the session file.
+    const result = await Promise.race([(async () => {
+      const res = await fetchImpl(url, { method: 'POST', headers, body, signal: ac.signal });
+      if (!res.ok) { report('summary-http-failed', res.status); return ''; }
+      const text = clampSummary(answerText(await res.text()), policy);
+      if (!text) report('summary-empty-output');
+      return text;
+    })(), timedOut]);
+    return result;
+  } catch (error) {
+    report(error?.name === 'AbortError' ? 'summary-timeout' : 'summary-call-failed');
     return '';
   } finally {
     clearTimeout(timer);
   }
 }
 
-// The answer's text, from whichever shape came back.
-function answerText(raw, ir) {
+function answerText(raw) {
   let doc;
   try { doc = JSON.parse(raw); } catch { return ''; }
-  if (Array.isArray(doc?.content)) {
-    return doc.content.filter(b => b?.type === 'text').map(b => b.text || '').join('\n');
-  }
-  if (doc?.choices?.[0]?.message?.content) return String(doc.choices[0].message.content);
-  if (Array.isArray(doc?.output)) {
-    let out = '';
-    for (const item of doc.output) {
-      if (typeof item?.text === 'string') out += item.text;
-      for (const c of item?.content || []) if (c?.type === 'output_text' || c?.type === 'text') out += c.text || '';
-    }
-    return out;
-  }
-  if (Array.isArray(doc?.candidates)) {
-    return doc.candidates.map(c => (c?.content?.parts || []).map(p => p.text || '').join('')).join('\n');
-  }
+  // A tool response is not a summary, even if accompanied by some assistant text.
+  if (doc?.content?.some?.(part => part?.type === 'tool_use') ||
+      doc?.choices?.[0]?.message?.tool_calls?.length ||
+      doc?.output?.some?.(item => ['function_call', 'custom_tool_call', 'local_shell_call'].includes(item?.type)) ||
+      doc?.candidates?.some?.(candidate => candidate?.content?.parts?.some?.(part => part.functionCall))) return '';
+  if (Array.isArray(doc?.content)) return doc.content.filter(part => part?.type === 'text')
+    .map(part => typeof part.text === 'string' ? part.text : '').join('\n');
+  if (typeof doc?.choices?.[0]?.message?.content === 'string') return doc.choices[0].message.content;
+  if (Array.isArray(doc?.output)) return doc.output.flatMap(item =>
+    (Array.isArray(item?.content) ? item.content : []).filter(part => ['output_text', 'text'].includes(part?.type)))
+    .map(part => typeof part.text === 'string' ? part.text : '').join('\n');
+  if (Array.isArray(doc?.candidates)) return doc.candidates.map(candidate =>
+    (candidate?.content?.parts || []).map(part => typeof part.text === 'string' ? part.text : '').join('')).join('\n');
   return '';
-}
+}