neoagent 3.2.1-beta.0 → 3.2.1-beta.10

package/server/services/ai/providers/ollama.js

@@ -1,4 +1,24 @@
+'use strict';
+
 const { BaseProvider } = require('./base');
+const { fetchResponseText, readResponseText } = require('../../network/http');
+const { createAbortError, isAbortError, throwIfAborted } = require('../../../utils/abort');
+const { readOllamaStream } = require('./ollama_stream');
+
+const MAX_CHAT_RESPONSE_BYTES = 16 * 1024 * 1024;
+
+function ollamaError(message, status = null) {
+  const error = new Error(
+    status == null
+      ? `Ollama request failed: ${message}`
+      : `Ollama request failed (HTTP ${status}): ${message}`,
+  );
+  if (status != null) error.status = status;
+  if (/does not support tools|tools.*not supported/i.test(String(message || ''))) {
+    error.code = 'OLLAMA_TOOLS_UNSUPPORTED';
+  }
+  return error;
+}
 
 class OllamaProvider extends BaseProvider {
   constructor(config = {}) {
@@ -8,22 +28,26 @@ class OllamaProvider extends BaseProvider {
     this.models = [];
   }
 
-  async listModels() {
+  async listModels(signal = null) {
     try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 5000);
-      const res = await fetch(`${this.baseUrl}/api/tags`, { signal: controller.signal });
-      clearTimeout(timer);
-      const data = await res.json();
+      const { response, text } = await fetchResponseText(`${this.baseUrl}/api/tags`, {
+        maxResponseBytes: 2 * 1024 * 1024,
+        serviceName: 'Ollama model catalog',
+        signal,
+        timeoutMs: 5000,
+      });
+      if (!response.ok) throw new Error(`Ollama /api/tags returned HTTP ${response.status}`);
+      const data = JSON.parse(text || '{}');
       this.models = (data.models || []).map(m => m.name);
       return this.models;
-    } catch {
+    } catch (err) {
+      if (isAbortError(err, signal)) throw createAbortError(signal);
       return [];
     }
   }
 
-  async ensureModel(model) {
-    const models = await this.listModels();
+  async ensureModel(model, signal = null) {
+    const models = await this.listModels(signal);
     // Normalization: Ollama often adds :latest if no tag is specified
     const normalizedModel = model.includes(':') ? model : `${model}:latest`;
     const found = models.some(m => m === model || m === normalizedModel);
@@ -39,12 +63,22 @@ class OllamaProvider extends BaseProvider {
       message: `Downloading local Ollama model '${model}'. First-time pulls can take a while.`
     });
     try {
-      const res = await fetch(`${this.baseUrl}/api/pull`, {
+      const { response, text } = await fetchResponseText(`${this.baseUrl}/api/pull`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: model, stream: false })
+        body: JSON.stringify({ name: model, stream: false }),
+        maxResponseBytes: 2 * 1024 * 1024,
+        serviceName: 'Ollama model pull',
+        signal,
+        timeoutMs: 5 * 60 * 1000,
       });
-      if (!res.ok) throw new Error(`Pull failed: ${res.statusText}`);
+      if (!response.ok) {
+        let detail = text;
+        try { detail = JSON.parse(text || '{}').error || text; } catch {}
+        throw new Error(
+          `Pull failed with HTTP ${response.status}: ${String(detail || response.statusText).slice(0, 500)}`,
+        );
+      }
       console.log(`[Ollama] Model '${model}' pulled successfully.`);
       this.onStatus?.({
         kind: 'model_download',
@@ -54,9 +88,10 @@ class OllamaProvider extends BaseProvider {
         message: `Local Ollama model '${model}' is ready.`
       });
       // Refresh local model list
-      await this.listModels();
+      await this.listModels(signal);
       return true;
     } catch (e) {
+      if (isAbortError(e, signal)) throw createAbortError(signal);
       this.onStatus?.({
         kind: 'model_download',
         status: 'failed',
@@ -122,42 +157,63 @@ class OllamaProvider extends BaseProvider {
   // status for others; surface both as real errors instead of letting callers
   // see a silently empty response. Tags models that reject tools so the caller
   // can transparently retry without them.
-  async postChat(body) {
+  async postChat(body, signal = null) {
     const res = await fetch(`${this.baseUrl}/api/chat`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal,
     });
     if (!res.ok) {
-      const detail = await res.text().catch(() => '');
+      const detail = await readResponseText(res, {
+        maxResponseBytes: 64 * 1024,
+        serviceName: 'Ollama chat error',
+      }).catch(() => '');
       let message = detail;
       try { message = JSON.parse(detail)?.error || detail; } catch {}
-      const err = new Error(`Ollama /api/chat failed (HTTP ${res.status}): ${message || res.statusText}`);
-      if (/does not support tools|tools.*not supported/i.test(message)) {
-        err.code = 'OLLAMA_TOOLS_UNSUPPORTED';
-      }
-      throw err;
+      throw ollamaError(message || res.statusText, res.status);
     }
     return res;
   }
 
+  async readChatResponse(body, signal = null) {
+    const res = await this.postChat(body, signal);
+    const text = await readResponseText(res, {
+      maxResponseBytes: MAX_CHAT_RESPONSE_BYTES,
+      serviceName: 'Ollama chat',
+    });
+    throwIfAborted(signal, 'Ollama chat aborted.');
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch (cause) {
+      throw new Error('Ollama /api/chat returned malformed JSON.', { cause });
+    }
+    if (data.error) throw ollamaError(data.error);
+    return data;
+  }
+
   async chat(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || 'llama3.1';
-    await this.ensureModel(model);
+    await this.ensureModel(model, options.signal);
 
-    let res;
+    let data;
     try {
-      res = await this.postChat(this.buildChatBody(messages, tools, { ...options, model }, false));
+      data = await this.readChatResponse(
+        this.buildChatBody(messages, tools, { ...options, model }, false),
+        options.signal,
+      );
     } catch (err) {
       if (err.code === 'OLLAMA_TOOLS_UNSUPPORTED' && tools.length > 0) {
         console.warn(`[Ollama] Model '${model}' does not support tools; retrying without them.`);
-        res = await this.postChat(this.buildChatBody(messages, [], { ...options, model }, false));
+        data = await this.readChatResponse(
+          this.buildChatBody(messages, [], { ...options, model }, false),
+          options.signal,
+        );
       } else {
         throw err;
       }
     }
-
-    const data = await res.json();
     const msg = data.message || {};
 
     return {
@@ -182,67 +238,39 @@ class OllamaProvider extends BaseProvider {
 
   async *stream(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || 'llama3.1';
-    await this.ensureModel(model);
-
-    let res;
-    try {
-      res = await this.postChat(this.buildChatBody(messages, tools, { ...options, model }, true));
-    } catch (err) {
-      if (err.code === 'OLLAMA_TOOLS_UNSUPPORTED' && tools.length > 0) {
-        console.warn(`[Ollama] Model '${model}' does not support tools; retrying stream without them.`);
-        res = await this.postChat(this.buildChatBody(messages, [], { ...options, model }, true));
-      } else {
-        throw err;
-      }
-    }
-
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let content = '';
-    let buffer = '';
-    let accumulatedToolCalls = [];
+    await this.ensureModel(model, options.signal);
 
+    let requestTools = tools;
+    let retriedWithoutTools = false;
     while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const data = JSON.parse(line);
-          if (data.message?.content) {
-            content += data.message.content;
-            yield { type: 'content', content: data.message.content };
-          }
-          if (data.message?.tool_calls && Array.isArray(data.message.tool_calls)) {
-            const mapped = data.message.tool_calls.map((tc, i) => ({
-              id: `call_ollama_${Date.now()}_${i}`,
-              type: 'function',
-              function: {
-                name: tc.function.name,
-                arguments: typeof tc.function.arguments === 'string' ? tc.function.arguments : JSON.stringify(tc.function.arguments || {})
-              }
-            }));
-            accumulatedToolCalls = accumulatedToolCalls.concat(mapped);
-          }
-          if (data.done) {
-            yield {
-              type: 'done',
-              content,
-              toolCalls: accumulatedToolCalls,
-              finishReason: accumulatedToolCalls.length > 0 ? 'tool_calls' : 'stop',
-              usage: data.prompt_eval_count ? {
-                promptTokens: data.prompt_eval_count || 0,
-                completionTokens: data.eval_count || 0,
-                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
-              } : null
-            };
-          }
-        } catch {}
+      let emittedChunk = false;
+      try {
+        const res = await this.postChat(
+          this.buildChatBody(messages, requestTools, { ...options, model }, true),
+          options.signal,
+        );
+        for await (const chunk of readOllamaStream(res, {
+          errorFactory: ollamaError,
+          maxResponseBytes: MAX_CHAT_RESPONSE_BYTES,
+          signal: options.signal,
+        })) {
+          emittedChunk = true;
+          yield chunk;
+        }
+        return;
+      } catch (err) {
+        if (
+          err.code === 'OLLAMA_TOOLS_UNSUPPORTED'
+          && tools.length > 0
+          && !retriedWithoutTools
+          && !emittedChunk
+        ) {
+          console.warn(`[Ollama] Model '${model}' does not support tools; retrying stream without them.`);
+          retriedWithoutTools = true;
+          requestTools = [];
+          continue;
+        }
+        throw err;
       }
     }
   }

package/server/services/ai/providers/ollama_stream.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const { waitForAbortableResult } = require('../../network/http');
+const { throwIfAborted } = require('../../../utils/abort');
+
+function malformedStreamError(cause = null) {
+  const error = new Error('Ollama /api/chat returned malformed streaming JSON.', cause ? { cause } : undefined);
+  error.code = 'OLLAMA_STREAM_MALFORMED';
+  return error;
+}
+
+function streamEndedEarlyError() {
+  const error = new Error('Ollama stream ended before sending a completion marker.');
+  error.code = 'OLLAMA_STREAM_INCOMPLETE';
+  return error;
+}
+
+function parseLine(line) {
+  if (!line.trim()) return null;
+  try {
+    const value = JSON.parse(line);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      throw malformedStreamError();
+    }
+    return value;
+  } catch (error) {
+    if (error?.code === 'OLLAMA_STREAM_MALFORMED') throw error;
+    throw malformedStreamError(error);
+  }
+}
+
+function usageFrom(data) {
+  if (data.prompt_eval_count == null && data.eval_count == null) return null;
+  const promptTokens = Number(data.prompt_eval_count) || 0;
+  const completionTokens = Number(data.eval_count) || 0;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+  };
+}
+
+function consumeData(data, state, errorFactory) {
+  if (data.error) throw errorFactory(data.error);
+  const chunks = [];
+  if (data.message?.content) {
+    const content = String(data.message.content);
+    state.content += content;
+    chunks.push({ type: 'content', content });
+  }
+  if (Array.isArray(data.message?.tool_calls)) {
+    for (const toolCall of data.message.tool_calls) {
+      const name = String(toolCall?.function?.name || '').trim();
+      if (!name) throw malformedStreamError();
+      state.toolCalls.push({
+        id: `call_ollama_${state.callSeed}_${state.nextCallIndex}`,
+        type: 'function',
+        function: {
+          name,
+          arguments: typeof toolCall.function.arguments === 'string'
+            ? toolCall.function.arguments
+            : JSON.stringify(toolCall.function.arguments || {}),
+        },
+      });
+      state.nextCallIndex += 1;
+    }
+  }
+  if (data.done === true) {
+    state.done = true;
+    chunks.push({
+      type: 'done',
+      content: state.content,
+      toolCalls: state.toolCalls,
+      finishReason: state.toolCalls.length > 0 ? 'tool_calls' : 'stop',
+      usage: usageFrom(data),
+    });
+  }
+  return chunks;
+}
+
+async function* readOllamaStream(response, options = {}) {
+  const reader = response?.body?.getReader?.();
+  if (!reader) throw new Error('Ollama /api/chat returned no streaming response body.');
+  const decoder = new TextDecoder();
+  const maxResponseBytes = Number(options.maxResponseBytes) > 0
+    ? Number(options.maxResponseBytes)
+    : 16 * 1024 * 1024;
+  const errorFactory = options.errorFactory || ((message) => new Error(String(message || 'Ollama error')));
+  const state = {
+    callSeed: Date.now(),
+    content: '',
+    done: false,
+    nextCallIndex: 0,
+    toolCalls: [],
+  };
+  let buffer = '';
+  let responseBytes = 0;
+
+  const emitLine = (line) => {
+    const data = parseLine(line);
+    return data ? consumeData(data, state, errorFactory) : [];
+  };
+
+  try {
+    while (!state.done) {
+      throwIfAborted(options.signal, 'Ollama stream aborted.');
+      const { done, value } = await waitForAbortableResult(
+        reader.read(),
+        options.signal,
+        'Ollama stream aborted.',
+      );
+      if (done) break;
+      responseBytes += value?.byteLength || 0;
+      if (responseBytes > maxResponseBytes) {
+        const error = new Error('Ollama stream exceeded its response safety limit.');
+        error.code = 'HTTP_RESPONSE_TOO_LARGE';
+        throw error;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        for (const chunk of emitLine(line)) yield chunk;
+        if (state.done) return;
+      }
+    }
+
+    buffer += decoder.decode();
+    if (buffer.trim()) {
+      for (const chunk of emitLine(buffer)) yield chunk;
+    }
+    if (!state.done) throw streamEndedEarlyError();
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock?.();
+  }
+}
+
+module.exports = {
+  readOllamaStream,
+};

package/server/services/ai/providers/openai.js

@@ -1,12 +1,20 @@
 const OpenAI = require('openai');
 const { OpenAICompatibleProvider } = require('./openaiCompatible');
+const { wrapProviderError } = require('./provider_error');
 
 class OpenAIProvider extends OpenAICompatibleProvider {
   constructor(config = {}) {
     super(config);
     this.name = 'openai';
     this.models = [
+      'gpt-5.6',
+      'gpt-5.6-sol',
+      'gpt-5.6-terra',
+      'gpt-5.6-luna',
       'gpt-5.5',
+      'gpt-5.4',
+      'gpt-5.4-mini',
+      'gpt-5.4-nano',
       'gpt-5',
       'gpt-5-mini',
       'gpt-5-nano',
@@ -16,9 +24,35 @@ class OpenAIProvider extends OpenAICompatibleProvider {
       'o4-mini'
     ];
     // Reasoning models: no temperature, use max_completion_tokens, support reasoning_effort
-    this.reasoningModels = new Set(['gpt-5.5', 'gpt-5', 'gpt-5-mini', 'gpt-5-nano', 'gpt-5.2', 'gpt-5.1', 'o1', 'o3', 'o3-pro', 'o4-mini', 'o3-mini']);
+    this.reasoningModels = new Set([
+      'gpt-5.6',
+      'gpt-5.6-sol',
+      'gpt-5.6-terra',
+      'gpt-5.6-luna',
+      'gpt-5.5',
+      'gpt-5.4',
+      'gpt-5.4-mini',
+      'gpt-5.4-nano',
+      'gpt-5',
+      'gpt-5-mini',
+      'gpt-5-nano',
+      'gpt-5.2',
+      'gpt-5.1',
+      'o1',
+      'o3',
+      'o3-pro',
+      'o4-mini',
+      'o3-mini',
+    ]);
     this.contextWindows = {
-      'gpt-5.5': 1000000,
+      'gpt-5.6': 1050000,
+      'gpt-5.6-sol': 1050000,
+      'gpt-5.6-terra': 1050000,
+      'gpt-5.6-luna': 1050000,
+      'gpt-5.5': 1050000,
+      'gpt-5.4': 1050000,
+      'gpt-5.4-mini': 400000,
+      'gpt-5.4-nano': 400000,
       'gpt-5': 400000,
       'gpt-5-mini': 400000,
       'gpt-5-nano': 128000,
@@ -36,15 +70,15 @@ class OpenAIProvider extends OpenAICompatibleProvider {
     });
   }
 
-  async listModels() {
+  async listModels(signal = null) {
     try {
-      const res = await this.client.models.list();
+      const res = await this.client.models.list({ signal });
       const DROP = /dall-e|whisper|tts|embed|moderat|realtime|audio|transcribe|search-api|-image-|babbage|davinci-002|^sora|-instruct/i;
       return res.data
         .filter((m) => !DROP.test(m.id))
         .map((m) => ({ id: m.id, name: m.id }));
     } catch (err) {
-      throw new Error(`Failed to list OpenAI models: ${err.message || String(err)}`);
+      throw wrapProviderError(err, 'Failed to list OpenAI models', { signal });
     }
   }
 
@@ -108,7 +142,7 @@ class OpenAIProvider extends OpenAICompatibleProvider {
     const model = options.model || this.config.model || this.getDefaultModel();
     const params = this._buildParams(model, messages, tools, options);
 
-    const response = await this.client.chat.completions.create(params);
+    const response = await this.client.chat.completions.create(params, { signal: options.signal });
     const choice = response.choices[0];
 
     return {
@@ -125,7 +159,7 @@ class OpenAIProvider extends OpenAICompatibleProvider {
     const params = this._buildParams(model, messages, tools, options);
     params.stream = true;
     params.stream_options = { include_usage: true };
-    const stream = await this.client.chat.completions.create(params);
+    const stream = await this.client.chat.completions.create(params, { signal: options.signal });
 
     let currentToolCalls = [];
     let content = '';

package/server/services/ai/providers/openaiCodex.js

@@ -1,6 +1,9 @@
+'use strict';
+
 const crypto = require('crypto');
 const OpenAI = require('openai');
 const { BaseProvider } = require('./base');
+const { wrapProviderError } = require('./provider_error');
 
 const DEFAULT_BASE_URL = 'https://chatgpt.com/backend-api/codex';
 const OPENAI_CODEX_EMPTY_INPUT_TEXT = ' ';
@@ -436,10 +439,13 @@ class OpenAICodexProvider extends BaseProvider {
     try {
       response = await this.client.responses.create(
         { model, ...request },
-        { headers: this._requestHeaders() },
+        { headers: this._requestHeaders(), signal: options.signal },
       );
     } catch (err) {
-      throw new Error(`OpenAI Codex request failed: ${formatOpenAIError(err)}`);
+      throw wrapProviderError(err, 'OpenAI Codex request failed', {
+        detail: formatOpenAIError(err),
+        signal: options.signal,
+      });
     }
 
     const toolCalls = extractToolCalls(response);
@@ -464,10 +470,13 @@ class OpenAICodexProvider extends BaseProvider {
     try {
       stream = await this.client.responses.create(
         { model, ...request, stream: true },
-        { headers: this._requestHeaders() },
+        { headers: this._requestHeaders(), signal: options.signal },
       );
     } catch (err) {
-      throw new Error(`OpenAI Codex request failed: ${formatOpenAIError(err)}`);
+      throw wrapProviderError(err, 'OpenAI Codex request failed', {
+        detail: formatOpenAIError(err),
+        signal: options.signal,
+      });
     }
 
     let content = '';

package/server/services/ai/providers/openrouter.js

@@ -1,5 +1,7 @@
 const OpenAI = require('openai');
 const { OpenAICompatibleProvider } = require('./openaiCompatible');
+const { fetchResponseText } = require('../../network/http');
+const { wrapProviderError } = require('./provider_error');
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
 
@@ -25,12 +27,26 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     });
   }
 
-  async listModels() {
-    const res = await fetch(`${this.baseURL}/models`, {
+  async listModels(signal = null) {
+    const { response, text } = await fetchResponseText(`${this.baseURL}/models`, {
       headers: { 'Authorization': `Bearer ${this.client.apiKey}` },
+      maxResponseBytes: 5 * 1024 * 1024,
+      serviceName: 'OpenRouter model catalog',
+      signal,
     });
-    if (!res.ok) throw new Error(`OpenRouter /models returned HTTP ${res.status}`);
-    const { data } = await res.json();
+    if (!response.ok) {
+      const error = new Error(`OpenRouter /models returned HTTP ${response.status}`);
+      error.status = response.status;
+      error.headers = response.headers;
+      throw error;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(text || '{}');
+    } catch {
+      throw new Error('OpenRouter /models returned invalid JSON.');
+    }
+    const { data } = payload;
     const models = data || [];
     for (const m of models) {
       if (m.context_length) contextWindowCache.set(m.id, m.context_length);
@@ -72,9 +88,11 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     const params = this._buildParams(model, messages, tools, options);
     let response;
     try {
-      response = await this.client.chat.completions.create(params);
+      response = await this.client.chat.completions.create(params, { signal: options.signal });
     } catch (err) {
-      throw new Error(`OpenRouter request failed: ${err?.message || String(err)}`);
+      throw wrapProviderError(err, 'OpenRouter request failed', {
+        signal: options.signal,
+      });
     }
     // OpenRouter returns HTTP 200 even for errors (rate limits, model unavailable, etc.)
     const orErr = this._extractOpenRouterError(response);
@@ -95,9 +113,11 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
 
     let stream;
     try {
-      stream = await this.client.chat.completions.create(params);
+      stream = await this.client.chat.completions.create(params, { signal: options.signal });
     } catch (err) {
-      throw new Error(`OpenRouter request failed: ${err?.message || String(err)}`);
+      throw wrapProviderError(err, 'OpenRouter request failed', {
+        signal: options.signal,
+      });
     }
 
     let toolCalls = [];
@@ -148,7 +168,9 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     }
     } catch (err) {
       // Re-throw SDK APIErrors (from OpenRouter SSE error events) with OpenRouter context.
-      throw new Error(`OpenRouter: ${err?.message || String(err)}`);
+      throw wrapProviderError(err, 'OpenRouter stream failed', {
+        signal: options.signal,
+      });
     }
 
     if (toolCalls.length > 0) {

package/server/services/ai/providers/provider_error.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { createAbortError, isAbortError } = require('../../../utils/abort');
+
+function sanitizeProviderErrorDetail(value) {
+  return String(value || 'Unknown provider error')
+    .slice(0, 2000)
+    .replace(/\b(Bearer|Basic|token)\s+[A-Za-z0-9._~+/=-]+/gi, '$1 [redacted]')
+    .replace(/([?&](?:key|api_key|access_token)=)[^&\s]+/gi, '$1[redacted]')
+    .replace(
+      /\b(api[_-]?key|access_token|refresh_token|authorization)\b\s*[:=]\s*["']?[^\s,"'}\]]+/gi,
+      '$1=[redacted]',
+    );
+}
+
+function wrapProviderError(error, prefix, options = {}) {
+  if (options.signal?.aborted) return createAbortError(options.signal);
+  if (isAbortError(error)) return error;
+
+  const detail = typeof options.detail === 'string'
+    ? options.detail
+    : error?.message || String(error);
+  const wrapped = new Error(
+    `${prefix}: ${sanitizeProviderErrorDetail(detail)}`,
+    { cause: error },
+  );
+  for (const property of ['status', 'statusCode', 'code', 'headers', 'response', 'type']) {
+    if (error?.[property] !== undefined) wrapped[property] = error[property];
+  }
+  return wrapped;
+}
+
+module.exports = {
+  sanitizeProviderErrorDetail,
+  wrapProviderError,
+};