dsh-vision-router 2.2.8 → 3.0.0

package/lib/ollama-cold-start.js

@@ -10,6 +10,17 @@ export const OLLAMA_WARMUP_KEEP_ALIVE = '30m'
 export const OLLAMA_WARMUP_TIMEOUT_MS = 120000
 export const OLLAMA_PROBE_TIMEOUT_MS = 1500
 
+// Capture the process fetch once, at module evaluation, exactly like the
+// Router-owned provider transport. A per-call `(...args) =>
+// globalThis.fetch(...args)` default would re-admit DVR's own later-installed
+// process-wide fetch wrappers (legacy proxy boundary, i18n/pi-ai bridge) into
+// Ollama warmup traffic, so the transport a warmup uses would depend on when
+// the warmup happens to run. Probe-only traffic must stay on the same frozen
+// transport as Router-owned provider calls.
+const moduleFetch = typeof globalThis.fetch === 'function'
+  ? globalThis.fetch.bind(globalThis)
+  : undefined
+
 function errorText(error) {
   return error && error.message ? error.message : String(error)
 }
@@ -71,6 +82,32 @@ function timeoutSignal(ms, controllers) {
   }
 }
 
+function abortReason(signal) {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : new Error('Ollama warmup aborted')
+}
+
+function awaitAbortable(task, signal) {
+  if (!signal || typeof signal.addEventListener !== 'function') return Promise.resolve(task)
+  if (signal.aborted) return Promise.reject(abortReason(signal))
+  return new Promise((resolve, reject) => {
+    let settled = false
+    const finish = (callback, value) => {
+      if (settled) return
+      settled = true
+      signal.removeEventListener('abort', onAbort)
+      callback(value)
+    }
+    const onAbort = () => finish(reject, abortReason(signal))
+    signal.addEventListener('abort', onAbort, { once: true })
+    Promise.resolve(task).then(
+      (value) => finish(resolve, value),
+      (error) => finish(reject, error),
+    )
+  })
+}
+
 async function cancelBody(response) {
   try {
     await response?.body?.cancel?.()
@@ -112,7 +149,7 @@ async function readOllamaJson(response, label) {
  * that the model finished loading.
  */
 export function createOllamaWarmupManager({
-  fetchImpl = (...args) => globalThis.fetch(...args),
+  fetchImpl = moduleFetch,
   logger,
   probeTimeoutMs = OLLAMA_PROBE_TIMEOUT_MS,
   warmupTimeoutMs = OLLAMA_WARMUP_TIMEOUT_MS,
@@ -121,6 +158,7 @@ export function createOllamaWarmupManager({
   const inFlight = new Map()
   const controllers = new Set()
   let disposed = false
+  let disposePromise
 
   const run = async (provider, reason, forceKeepAlive) => {
     const key = providerKey(provider)
@@ -136,12 +174,18 @@ export function createOllamaWarmupManager({
 
     const probe = timeoutSignal(probeTimeoutMs, controllers)
     try {
-      const response = await fetchImpl(psUrl, { method: 'GET', signal: probe.signal })
+      const response = await awaitAbortable(
+        fetchImpl(psUrl, { method: 'GET', signal: probe.signal }),
+        probe.signal,
+      )
       if (!response?.ok) {
-        await cancelBody(response)
+        await awaitAbortable(cancelBody(response), probe.signal)
         return { ok: false, reason: `probe-http-${response?.status ?? 'unknown'}` }
       }
-      const payload = await readOllamaJson(response, 'Ollama /api/ps response')
+      const payload = await awaitAbortable(
+        readOllamaJson(response, 'Ollama /api/ps response'),
+        probe.signal,
+      )
       loaded = psContainsModel(payload, provider.model)
       if (loaded && forceKeepAlive !== true) {
         return {
@@ -159,7 +203,7 @@ export function createOllamaWarmupManager({
 
     const warm = timeoutSignal(warmupTimeoutMs, controllers)
     try {
-      const response = await fetchImpl(generateUrl, {
+      const response = await awaitAbortable(fetchImpl(generateUrl, {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({
@@ -169,16 +213,19 @@ export function createOllamaWarmupManager({
           keep_alive: keepAlive,
         }),
         signal: warm.signal,
-      })
+      }), warm.signal)
       if (!response?.ok) {
-        await cancelBody(response)
+        await awaitAbortable(cancelBody(response), warm.signal)
         return { ok: false, reason: `warmup-http-${response?.status ?? 'unknown'}` }
       }
       // Do not cancel a successful preload body. A real HTTP fetch resolves as
       // soon as headers are available, so draining the bounded JSON response is
       // what proves Ollama finished loading the model before the inference
       // deadline is allowed to start.
-      await readOllamaJson(response, 'Ollama preload response')
+      await awaitAbortable(
+        readOllamaJson(response, 'Ollama preload response'),
+        warm.signal,
+      )
       const durationMs = Date.now() - startedAt
       if (durationMs >= 1000) {
         try {
@@ -240,12 +287,17 @@ export function createOllamaWarmupManager({
   }
 
   const dispose = () => {
+    if (disposePromise) return disposePromise
     disposed = true
     for (const controller of controllers) {
       try { controller.abort(new Error('Vision Router disposed')) } catch { /* best effort */ }
     }
-    controllers.clear()
-    inFlight.clear()
+    const admitted = [...inFlight.values()]
+    disposePromise = Promise.allSettled(admitted).then(() => {
+      controllers.clear()
+      inFlight.clear()
+    })
+    return disposePromise
   }
 
   return { ensure, background, dispose }
@@ -291,7 +343,7 @@ export function installOllamaColdStartGuard(ctx, config = {}, core, options = {}
 
   let rawScope
   let scopeUnwatch
-  const manager = options.manager || createOllamaWarmupManager({ logger: ctx.logger })
+  const manager = options.manager || createOllamaWarmupManager({ logger: options.logger ?? ctx.logger })
   const rawInject = typeof ctx.inject === 'function' ? ctx.inject.bind(ctx) : undefined
   const rawOn = typeof ctx.on === 'function' ? ctx.on.bind(ctx) : undefined
   const rawLlm = ctx.llm
@@ -325,14 +377,10 @@ export function installOllamaColdStartGuard(ctx, config = {}, core, options = {}
       try { scopeUnwatch() } catch { /* best effort */ }
       scopeUnwatch = undefined
     }
-    backgroundWarm('settings-ready')
-    if (typeof scope.watch === 'function') {
-      try {
-        scopeUnwatch = scope.watch(() => backgroundWarm('settings-changed'))
-      } catch {
-        scopeUnwatch = undefined
-      }
-    }
+
+    // Own this dynamic Settings generation before it can start warmup work or
+    // install a watcher. A rejected child fiber must never leave rawScope
+    // pointing at a dead Settings service.
     try {
       ownerCtx?.effect?.(
         () => () => {
@@ -345,7 +393,17 @@ export function installOllamaColdStartGuard(ctx, config = {}, core, options = {}
         'vision-router: Ollama warmup settings lifecycle',
       )
     } catch {
-      /* lifecycle registration is best effort */
+      if (rawScope === scope) rawScope = undefined
+      return
+    }
+
+    backgroundWarm('settings-ready')
+    if (typeof scope.watch === 'function') {
+      try {
+        scopeUnwatch = scope.watch(() => backgroundWarm('settings-changed'))
+      } catch {
+        scopeUnwatch = undefined
+      }
     }
   }
 
@@ -455,18 +513,24 @@ export function installOllamaColdStartGuard(ctx, config = {}, core, options = {}
 
   try {
     ctx.effect?.(
-      () => () => {
+      () => async () => {
         rawScope = undefined
         if (typeof scopeUnwatch === 'function') {
           try { scopeUnwatch() } catch { /* best effort */ }
           scopeUnwatch = undefined
         }
-        manager.dispose()
+        await manager.dispose()
       },
       'vision-router: Ollama cold-start guard',
     )
   } catch {
-    /* cleanup registration is best effort */
+    rawScope = undefined
+    if (typeof scopeUnwatch === 'function') {
+      try { scopeUnwatch() } catch { /* best effort */ }
+      scopeUnwatch = undefined
+    }
+    void Promise.resolve(manager.dispose()).catch(() => {})
+    return ctx
   }
 
   // Composition-level localOllama may already be enabled before Settings

package/lib/pi-ai-bridge-wire-compat.js

@@ -342,8 +342,9 @@ export function installPiAiBridgeWireCompat(ctx, logger) {
   }
   try {
     ctx?.effect?.(() => cleanup, 'vision-router: pi-ai bridge wire compatibility')
-  } catch {
-    // Direct callers without Cordis lifecycle still receive the cleanup below.
+  } catch (error) {
+    cleanup()
+    throw error
   }
   return cleanup
 }

package/lib/proxy-dispatcher-pool.js

@@ -1,96 +1,155 @@
-async function closeDispatcher(dispatcher) {
-  if (!dispatcher || (typeof dispatcher !== 'object' && typeof dispatcher !== 'function')) return
-  try {
-    if (typeof dispatcher.close === 'function') {
-      await dispatcher.close()
-      return
-    }
-    if (typeof dispatcher.destroy === 'function') await dispatcher.destroy()
-  } catch {
-    // Cleanup must not turn a completed request into an unload failure.
-  }
+import { proxyDispatcherLike, } from './proxy-routing.js';
+function objectRecord(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function')
+        ? value
+        : undefined;
 }
-
-export function createProxyDispatcherPool({ importUndici = () => import('undici'), label = 'vision proxy transport' } = {}) {
-  let cachedEntry
-  let disposed = false
-  let disposePromise
-  const liveEntries = new Set()
-
-  const maybeCloseEntry = (entry) => {
-    if (!entry.obsolete || entry.refs !== 0 || !entry.dispatcher || entry.closing) return
-    entry.closing = Promise.resolve().then(() => closeDispatcher(entry.dispatcher)).finally(() => {
-      liveEntries.delete(entry)
-      entry.resolveDone()
-    })
-  }
-  const retireEntry = (entry) => {
-    if (!entry || entry.obsolete) return
-    entry.obsolete = true
-    maybeCloseEntry(entry)
-  }
-  const createEntry = (proxyUrl) => {
-    let resolveDone
-    const entry = {
-      proxyUrl, refs: 0, obsolete: false, dispatcher: undefined, getGlobalDispatcher: undefined, closing: undefined,
-      done: new Promise((resolve) => { resolveDone = resolve }), resolveDone: () => resolveDone(), promise: undefined,
-    }
-    liveEntries.add(entry)
-    entry.promise = Promise.resolve().then(() => importUndici()).then(({ ProxyAgent, getGlobalDispatcher }) => {
-      if (typeof ProxyAgent !== 'function') throw new Error(`${label}: undici ProxyAgent is unavailable`)
-      if (typeof getGlobalDispatcher !== 'function') throw new Error(`${label}: undici getGlobalDispatcher is unavailable`)
-      entry.getGlobalDispatcher = getGlobalDispatcher
-      entry.dispatcher = new ProxyAgent(proxyUrl)
-      maybeCloseEntry(entry)
-      return entry.dispatcher
-    }).catch((error) => {
-      if (cachedEntry === entry) cachedEntry = undefined
-      liveEntries.delete(entry)
-      entry.resolveDone()
-      throw error
-    })
-    return entry
-  }
-  const reconcile = (proxyUrl) => {
-    if (cachedEntry && cachedEntry.proxyUrl !== proxyUrl) {
-      const previous = cachedEntry
-      cachedEntry = undefined
-      retireEntry(previous)
-    }
-  }
-  const acquire = async (proxyUrl) => {
-    if (disposed) throw new Error(`${label}: dispatcher pool is disposed`)
-    let entry = cachedEntry
-    if (!entry || entry.proxyUrl !== proxyUrl || entry.obsolete) {
-      if (entry) retireEntry(entry)
-      entry = createEntry(proxyUrl)
-      cachedEntry = entry
-    }
-    entry.refs += 1
+async function closeDispatcher(dispatcher) {
+    const value = objectRecord(dispatcher);
+    if (value === undefined)
+        return;
     try {
-      const dispatcher = await entry.promise
-      let released = false
-      return { dispatcher, getGlobalDispatcher: entry.getGlobalDispatcher, release() {
-        if (released) return
-        released = true
-        entry.refs = Math.max(0, entry.refs - 1)
-        maybeCloseEntry(entry)
-      } }
-    } catch (error) {
-      entry.refs = Math.max(0, entry.refs - 1)
-      maybeCloseEntry(entry)
-      throw error
+        if (typeof value.close === 'function') {
+            await value.close.call(dispatcher);
+            return;
+        }
+        if (typeof value.destroy === 'function')
+            await value.destroy.call(dispatcher);
     }
-  }
-  const dispose = () => {
-    if (disposePromise) return disposePromise
-    disposed = true
-    const current = cachedEntry
-    cachedEntry = undefined
-    retireEntry(current)
-    for (const entry of liveEntries) retireEntry(entry)
-    disposePromise = Promise.all([...liveEntries].map((entry) => entry.done)).then(() => undefined)
-    return disposePromise
-  }
-  return Object.freeze({ acquire, reconcile, dispose })
+    catch {
+        // Cleanup must not turn a completed request into an unload failure.
+    }
+}
+export function createProxyDispatcherPool({ importUndici = () => import('undici'), label = 'vision proxy transport', } = {}) {
+    let cachedEntry;
+    let disposed = false;
+    let disposePromise;
+    const liveEntries = new Set();
+    const maybeCloseEntry = (entry) => {
+        if (!entry.obsolete || entry.refs !== 0 || !entry.dispatcher || entry.closing)
+            return;
+        entry.closing = Promise.resolve()
+            .then(() => closeDispatcher(entry.dispatcher))
+            .finally(() => {
+            liveEntries.delete(entry);
+            entry.resolveDone();
+        });
+    };
+    const retireEntry = (entry) => {
+        if (!entry || entry.obsolete)
+            return;
+        entry.obsolete = true;
+        maybeCloseEntry(entry);
+    };
+    const createEntry = (proxyUrl) => {
+        let resolveDone;
+        const done = new Promise((resolve) => { resolveDone = resolve; });
+        const entry = {
+            proxyUrl,
+            refs: 0,
+            obsolete: false,
+            dispatcher: undefined,
+            getGlobalDispatcher: undefined,
+            closing: undefined,
+            done,
+            resolveDone,
+            promise: undefined,
+        };
+        liveEntries.add(entry);
+        entry.promise = Promise.resolve()
+            .then(importUndici)
+            .then((moduleValue) => {
+            const module = objectRecord(moduleValue);
+            const ProxyAgent = module?.ProxyAgent;
+            const getGlobalDispatcher = module?.getGlobalDispatcher;
+            if (typeof ProxyAgent !== 'function') {
+                throw new Error(`${label}: undici ProxyAgent is unavailable`);
+            }
+            if (typeof getGlobalDispatcher !== 'function') {
+                throw new Error(`${label}: undici getGlobalDispatcher is unavailable`);
+            }
+            const Constructor = ProxyAgent;
+            const dispatcher = new Constructor(proxyUrl);
+            if (!proxyDispatcherLike(dispatcher)) {
+                throw new Error(`${label}: undici ProxyAgent has no dispatcher contract`);
+            }
+            entry.getGlobalDispatcher = () => {
+                const globalDispatcher = getGlobalDispatcher.call(moduleValue);
+                if (!proxyDispatcherLike(globalDispatcher)) {
+                    throw new Error(`${label}: undici global dispatcher has no dispatcher contract`);
+                }
+                return globalDispatcher;
+            };
+            entry.dispatcher = dispatcher;
+            maybeCloseEntry(entry);
+            return entry.dispatcher;
+        })
+            .catch((error) => {
+            if (cachedEntry === entry)
+                cachedEntry = undefined;
+            liveEntries.delete(entry);
+            entry.resolveDone();
+            throw error;
+        });
+        return entry;
+    };
+    const reconcile = (proxyUrl) => {
+        if (cachedEntry && cachedEntry.proxyUrl !== proxyUrl) {
+            const previous = cachedEntry;
+            cachedEntry = undefined;
+            retireEntry(previous);
+        }
+    };
+    const acquire = async (proxyUrl) => {
+        if (disposed)
+            throw new Error(`${label}: dispatcher pool is disposed`);
+        let entry = cachedEntry;
+        if (!entry || entry.proxyUrl !== proxyUrl || entry.obsolete) {
+            if (entry)
+                retireEntry(entry);
+            entry = createEntry(proxyUrl);
+            cachedEntry = entry;
+        }
+        entry.refs += 1;
+        try {
+            const promise = entry.promise;
+            if (!promise)
+                throw new Error(`${label}: dispatcher entry failed to initialize`);
+            const dispatcher = await promise;
+            const getGlobalDispatcher = entry.getGlobalDispatcher;
+            if (!getGlobalDispatcher) {
+                throw new Error(`${label}: global dispatcher accessor is unavailable`);
+            }
+            let released = false;
+            return {
+                dispatcher,
+                getGlobalDispatcher,
+                release() {
+                    if (released)
+                        return;
+                    released = true;
+                    entry.refs = Math.max(0, entry.refs - 1);
+                    maybeCloseEntry(entry);
+                },
+            };
+        }
+        catch (error) {
+            entry.refs = Math.max(0, entry.refs - 1);
+            maybeCloseEntry(entry);
+            throw error;
+        }
+    };
+    const dispose = () => {
+        if (disposePromise)
+            return disposePromise;
+        disposed = true;
+        const current = cachedEntry;
+        cachedEntry = undefined;
+        retireEntry(current);
+        for (const entry of liveEntries)
+            retireEntry(entry);
+        disposePromise = Promise.all([...liveEntries].map((entry) => entry.done)).then(() => undefined);
+        return disposePromise;
+    };
+    return Object.freeze({ acquire, reconcile, dispose });
 }

package/lib/proxy-routing.js

@@ -1,76 +1,100 @@
-import { domainToASCII } from 'node:url'
-
+import { URL, domainToASCII } from 'node:url';
 function objectLike(value) {
-  return value !== null && (typeof value === 'object' || typeof value === 'function')
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
 }
-
 /** True only when the user explicitly configured a Vision Router proxy override. */
 export function visionProxyOverrideConfigured(config = {}) {
-  const value = config && typeof config === 'object' ? config.proxy : undefined
-  return typeof value === 'string' && value.trim() !== ''
+    const value = objectLike(config)
+        ? config.proxy
+        : undefined;
+    return typeof value === 'string' && value.trim() !== '';
 }
-
 /**
  * Canonicalize a configured/request hostname for proxy admission only.
  * Persisted settings stay untouched; this removes DNS presentation differences
  * (case, one trailing dot and Unicode) without broadening the suffix policy.
  */
 export function canonicalProxyHost(value) {
-  let host = String(value ?? '').trim()
-  if (host === '') return ''
-  if (host.endsWith('.')) host = host.slice(0, -1)
-  if (host === '') return ''
-
-  // WHATWG URL.hostname keeps IPv6 literals bracketed. domainToASCII does not
-  // accept a bare IPv6 literal, so preserve the bracketed spelling and only
-  // case-fold it. Proxy hosts are otherwise DNS names and can be IDNA-folded.
-  if (host.startsWith('[') && host.endsWith(']')) return host.toLowerCase()
-  const ascii = domainToASCII(host)
-  return (ascii || host).toLowerCase()
+    let host = String(value ?? '').trim();
+    if (host === '')
+        return '';
+    if (host.endsWith('.'))
+        host = host.slice(0, -1);
+    if (host === '')
+        return '';
+    // WHATWG URL.hostname keeps IPv6 literals bracketed. domainToASCII does not
+    // accept a bare IPv6 literal, so preserve the bracketed spelling and only
+    // case-fold it. Proxy hosts are otherwise DNS names and can be IDNA-folded.
+    if (host.startsWith('[') && host.endsWith(']'))
+        return host.toLowerCase();
+    const ascii = domainToASCII(host);
+    return (ascii || host).toLowerCase();
 }
-
 /** Exact host or subdomain match using one shared proxy-host interpretation. */
-export function proxyHostMatchesAny(hostname, hosts) {
-  const host = canonicalProxyHost(hostname)
-  if (host === '') return false
-  return (hosts ?? []).some((raw) => {
-    const candidate = canonicalProxyHost(raw)
-    return candidate !== '' && (host === candidate || host.endsWith(`.${candidate}`))
-  })
+export function proxyHostMatchesAny(hostname, hosts = []) {
+    const host = canonicalProxyHost(hostname);
+    if (host === '')
+        return false;
+    return hosts.some((raw) => {
+        const candidate = canonicalProxyHost(raw);
+        return candidate !== '' && (host === candidate || host.endsWith(`.${candidate}`));
+    });
 }
-
 export function proxyDispatcherLike(value) {
-  return objectLike(value) && typeof value.dispatch === 'function'
+    return objectLike(value)
+        && typeof value.dispatch === 'function';
 }
-
 function proxyDispatchOriginUrl(options) {
-  try {
-    const origin = options?.origin
-    if (origin instanceof URL) return origin
-    if (origin !== undefined && origin !== null) return new URL(String(origin))
-  } catch {
-    // Unknown dispatcher shapes never authorize the plugin proxy.
-  }
-  return undefined
+    try {
+        const origin = objectLike(options)
+            ? options.origin
+            : undefined;
+        if (origin instanceof URL)
+            return origin;
+        if (origin !== undefined && origin !== null)
+            return new URL(String(origin));
+    }
+    catch {
+        // Unknown dispatcher shapes never authorize the plugin proxy.
+    }
+    return undefined;
 }
-
 /**
  * Preserve Fetch/Undici redirect semantics while keeping proxyHosts an upper
  * bound on every hop after a request has entered the DVR proxy override.
  * The fallback dispatcher is borrowed, never owned or closed by this selector.
  */
 export function createPerHopProxyDispatcher(proxyDispatcher, fallbackDispatcher, proxyHosts = []) {
-  if (!proxyDispatcherLike(proxyDispatcher) || !proxyDispatcherLike(fallbackDispatcher)) {
-    throw new TypeError('vision proxy hop selector requires proxy and fallback dispatchers')
-  }
-  const hosts = [...proxyHosts]
-  return Object.freeze({
-    dispatch(options, handler) {
-      const url = proxyDispatchOriginUrl(options)
-      const target = url && proxyHostMatchesAny(url.hostname, hosts)
-        ? proxyDispatcher
-        : fallbackDispatcher
-      return target.dispatch(options, handler)
-    },
-  })
+    if (!proxyDispatcherLike(proxyDispatcher) || !proxyDispatcherLike(fallbackDispatcher)) {
+        throw new TypeError('vision proxy hop selector requires proxy and fallback dispatchers');
+    }
+    const hosts = [...proxyHosts];
+    const proxy = proxyDispatcher;
+    const fallback = fallbackDispatcher;
+    // Fetch types model a full Undici Dispatcher, while fetch dispatch itself
+    // consumes the dispatch() seam. A Host dispatcher may expose dispatch as a
+    // frozen/non-configurable own property; using that borrowed object directly
+    // as a Proxy target would make an overriding get trap violate ECMAScript
+    // Proxy invariants. Use a neutral shell with the same prototype instead.
+    //
+    // Every non-dispatch read still resolves against and binds to the real
+    // fallback Dispatcher, so the wrapper does not become a second owner for
+    // close/destroy/event state and instanceof-style prototype checks remain
+    // compatible with the borrowed dispatcher.
+    const shell = Object.create(Object.getPrototypeOf(fallback));
+    return new Proxy(shell, {
+        get(_target, property) {
+            if (property === 'dispatch') {
+                return (options, handler) => {
+                    const url = proxyDispatchOriginUrl(options);
+                    const selected = url && proxyHostMatchesAny(url.hostname, hosts)
+                        ? proxy
+                        : fallback;
+                    return selected.dispatch(options, handler);
+                };
+            }
+            const value = Reflect.get(fallback, property, fallback);
+            return typeof value === 'function' ? value.bind(fallback) : value;
+        },
+    });
 }

package/lib/proxy-url-compat.js

@@ -1,12 +1,5 @@
-/**
- * Project the persisted proxy setting into the syntax accepted by Undici.
- *
- * Older Vision Router settings copy explicitly recommended `socks5h://`.
- * Keep that persisted user intent untouched and translate only at the runtime
- * dispatcher boundary. Deliberately do not validate or reinterpret any other
- * proxy scheme here: Undici remains the execution authority.
- */
 export function effectiveProxyUrlForUndici(value) {
-  if (typeof value !== 'string') return value
-  return value.replace(/^(\s*)socks5h:/i, '$1socks5:')
+    if (typeof value !== 'string')
+        return value;
+    return value.replace(/^(\s*)socks5h:/i, '$1socks5:');
 }