droid-patch 0.15.1 → 0.16.0

package/dist/cli.mjs

@@ -29,9 +29,14 @@ const fs = require('fs');
 const DEBUG = process.env.DROID_SEARCH_DEBUG === '1';
 const PORT = parseInt(process.env.SEARCH_PROXY_PORT || '0');
 const FACTORY_API = 'https://api.factory.ai';
+const SEARCH_ROUTE_ALIASES = new Set(['/api/tools/web-search', '/api/tools/exa/search']);
 
 function log() { if (DEBUG) console.error.apply(console, ['[websearch]'].concat(Array.from(arguments))); }
 
+function isSearchRequest(url, method) {
+  return method === 'POST' && SEARCH_ROUTE_ALIASES.has(url.pathname);
+}
+
 // === External Search Providers ===
 
 async function searchSmitheryExa(query, numResults) {
@@ -204,7 +209,7 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
-  if (url.pathname === '/api/tools/exa/search' && req.method === 'POST') {
+  if (isSearchRequest(url, req.method)) {
     let body = '';
     req.on('data', function(c) { body += c; });
     req.on('end', async function() {
@@ -281,7 +286,6 @@ function generateNativeSearchProxyServer(factoryApiUrl = "https://api.factory.ai
 
 const http = require('http');
 const https = require('https');
-const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -289,13 +293,18 @@ const os = require('os');
 const DEBUG = process.env.DROID_SEARCH_DEBUG === '1';
 const PORT = parseInt(process.env.SEARCH_PROXY_PORT || '0');
 const FACTORY_API = '${factoryApiUrl}';
+const SEARCH_ROUTE_ALIASES = new Set(['/api/tools/web-search', '/api/tools/exa/search']);
+const SUPPORTED_PROVIDERS = new Set(['anthropic', 'openai']);
 
 function log(...args) { if (DEBUG) console.error('[websearch]', ...args); }
 
-// === Settings Configuration ===
+function isSearchRequest(url, method) {
+  return method === 'POST' && SEARCH_ROUTE_ALIASES.has(url.pathname);
+}
 
 let cachedSettings = null;
 let settingsLastModified = 0;
+let lastObservedProvider = null;
 
 function getFactorySettings() {
   const settingsPath = path.join(os.homedir(), '.factory', 'settings.json');
@@ -311,151 +320,409 @@ function getFactorySettings() {
   }
 }
 
-function getCurrentModelConfig() {
-  const settings = getFactorySettings();
-  if (!settings) return null;
-  
-  const currentModelId = settings.sessionDefaultSettings?.model;
-  if (!currentModelId) return null;
-  
-  const customModels = settings.customModels || [];
-  const modelConfig = customModels.find(m => m.id === currentModelId);
-  
-  if (modelConfig) {
-    log('Model:', modelConfig.displayName, '| Provider:', modelConfig.provider);
-    return modelConfig;
+function listCustomModels(settings) {
+  return Array.isArray(settings && settings.customModels) ? settings.customModels : [];
+}
+
+function isSupportedModel(modelConfig, preferredProvider) {
+  return !!(
+    modelConfig &&
+    SUPPORTED_PROVIDERS.has(modelConfig.provider) &&
+    (!preferredProvider || modelConfig.provider === preferredProvider) &&
+    modelConfig.id &&
+    modelConfig.baseUrl &&
+    modelConfig.apiKey &&
+    modelConfig.model
+  );
+}
+
+function buildCandidateModelIds(settings) {
+  const candidates = [
+    process.env.DROID_SEARCH_MODEL_ID,
+    settings && settings.sessionDefaultSettings && settings.sessionDefaultSettings.model,
+    settings && settings.missionModelSettings && settings.missionModelSettings.workerModel,
+    settings && settings.missionModelSettings && settings.missionModelSettings.validationWorkerModel,
+    settings && settings.missionModelSettings && settings.missionModelSettings.orchestratorModel,
+  ];
+  const unique = [];
+  for (const candidate of candidates) {
+    if (candidate && !unique.includes(candidate)) unique.push(candidate);
   }
-  
-  if (!currentModelId.startsWith('custom:')) return null;
-  log('Model not found:', currentModelId);
-  return null;
+  return unique;
 }
 
-// === Native Provider WebSearch ===
+function summarizeSupportedModels(settings, preferredProvider) {
+  return listCustomModels(settings)
+    .filter(function(modelConfig) { return isSupportedModel(modelConfig, preferredProvider); })
+    .map(function(modelConfig) { return modelConfig.id + ' [' + modelConfig.provider + ']'; })
+    .join(', ');
+}
 
-async function searchAnthropicNative(query, numResults, modelConfig) {
-  const { baseUrl, apiKey, model } = modelConfig;
-  
-  try {
-    const requestBody = {
-      model: model,
-      max_tokens: 4096,
-      stream: false,
-      system: 'You are a web search assistant. Use the web_search tool to find relevant information and return the results.',
-      tools: [{ type: 'web_search_20250305', name: 'web_search', max_uses: 1 }],
-      tool_choice: { type: 'tool', name: 'web_search' },
-      messages: [{ role: 'user', content: 'Search the web for: ' + query + '\\n\\nReturn up to ' + numResults + ' relevant results.' }]
+function getCurrentModelConfig(preferredProvider) {
+  const settings = getFactorySettings();
+  if (!settings) {
+    return {
+      error: 'Failed to load ~/.factory/settings.json for native websearch',
+      statusCode: 500,
     };
-    
-    let endpoint = baseUrl;
-    if (!endpoint.endsWith('/v1/messages')) endpoint = endpoint.replace(/\\/$/, '') + '/v1/messages';
-    
-    log('Anthropic search:', query, '→', endpoint);
-    
-    const bodyStr = JSON.stringify(requestBody).replace(/'/g, "'\\\\''");
-    const curlCmd = 'curl -s -X POST "' + endpoint + '" -H "Content-Type: application/json" -H "anthropic-version: 2023-06-01" -H "x-api-key: ' + apiKey + '" -d \\'' + bodyStr + "\\'";
-    const responseStr = execSync(curlCmd, { encoding: 'utf-8', timeout: 60000 });
-    
-    let response;
-    try { response = JSON.parse(responseStr); } catch { return null; }
-    if (response.error) { log('API error:', response.error.message); return null; }
-    
-    const results = [];
-    for (const block of (response.content || [])) {
-      if (block.type === 'web_search_tool_result') {
-        for (const result of (block.content || [])) {
-          if (result.type === 'web_search_result') {
-            results.push({
-              title: result.title || '',
-              url: result.url || '',
-              content: result.snippet || result.page_content || ''
-            });
-          }
+  }
+
+  const customModels = listCustomModels(settings);
+  const candidateIds = buildCandidateModelIds(settings);
+  for (const candidateId of candidateIds) {
+    const modelConfig = customModels.find(function(model) {
+      return model.id === candidateId && isSupportedModel(model, preferredProvider);
+    });
+    if (modelConfig) {
+      lastObservedProvider = modelConfig.provider;
+      log('Resolved model:', modelConfig.id, '| Provider:', modelConfig.provider);
+      return { modelConfig: modelConfig, source: candidateId };
+    }
+  }
+
+  const fallbackModels = customModels.filter(function(modelConfig) {
+    return isSupportedModel(modelConfig, preferredProvider);
+  });
+  if (fallbackModels.length === 1) {
+    lastObservedProvider = fallbackModels[0].provider;
+    log('Falling back to only supported model:', fallbackModels[0].id);
+    return { modelConfig: fallbackModels[0], source: 'single-supported-model' };
+  }
+
+  const providerLabel = preferredProvider || 'anthropic/openai';
+  const supported = summarizeSupportedModels(settings, preferredProvider);
+  const message = supported
+    ? 'Could not resolve an active ' + providerLabel + ' custom model for native websearch. Available models: ' + supported
+    : 'No supported ' + providerLabel + ' custom models found in ~/.factory/settings.json';
+
+  return { error: message, statusCode: 400 };
+}
+
+function normalizeEndpoint(baseUrl, suffix) {
+  return baseUrl.endsWith(suffix) ? baseUrl : baseUrl.replace(/\\/$/, '') + suffix;
+}
+
+function extractErrorMessage(value) {
+  if (!value) return 'Unknown upstream error';
+  if (typeof value === 'string') return value;
+  if (typeof value.message === 'string') return value.message;
+  return JSON.stringify(value);
+}
+
+function sleep(ms) {
+  return new Promise(function(resolve) { setTimeout(resolve, ms); });
+}
+
+function getRetryDelayMs(attempt) {
+  return Math.min(250 * Math.pow(2, attempt - 1), 2000);
+}
+
+function isRetryableSearchFailure(statusCode, message) {
+  if (statusCode === 408 || statusCode === 425 || statusCode === 429) return true;
+  if (statusCode >= 500 && statusCode <= 599) return true;
+
+  const normalized = String(message || '').toLowerCase();
+  return normalized.includes('proxy failed:') ||
+    normalized.includes('client network socket disconnected before secure tls connection was established') ||
+    normalized.includes('fetch failed') ||
+    normalized.includes('socket hang up') ||
+    normalized.includes('request timed out') ||
+    normalized.includes('timed out') ||
+    normalized.includes('econnreset') ||
+    normalized.includes('ecconnreset') ||
+    normalized.includes('econnrefused') ||
+    normalized.includes('ehostunreach') ||
+    normalized.includes('enotfound') ||
+    normalized.includes('eai_again');
+}
+
+function pushUniqueResult(results, result) {
+  if (!result || !result.url) return;
+  if (results.some(function(existing) { return existing.url === result.url; })) return;
+  results.push({
+    title: result.title || result.url,
+    url: result.url,
+    content: result.content || '',
+  });
+}
+
+function parseOpenAITextResults(text, numResults) {
+  const results = [];
+  const lines = String(text || '').split(/\\r?\\n/);
+  let current = null;
+
+  function flushCurrent() {
+    if (!current || !current.url) {
+      current = null;
+      return;
+    }
+    pushUniqueResult(results, {
+      title: current.title,
+      url: current.url,
+      content: current.content.join(' ').trim(),
+    });
+    current = null;
+  }
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const titleMatch = line.match(/^\\d+\\.\\s+(?:\\*\\*(.+?)\\*\\*|(.+))$/);
+    if (titleMatch) {
+      flushCurrent();
+      current = {
+        title: (titleMatch[1] || titleMatch[2] || '').trim(),
+        url: '',
+        content: [],
+      };
+      continue;
+    }
+
+    const urlMatch = line.match(/^(?:[-*]\\s+)?(https?:\\/\\/\\S+)/);
+    if (urlMatch) {
+      if (!current) {
+        current = { title: urlMatch[1], url: '', content: [] };
+      }
+      current.url = urlMatch[1].replace(/[),.;]+$/, '');
+      continue;
+    }
+
+    const bulletTextMatch = line.match(/^[-*]\\s+(.+)/);
+    const contentText = (bulletTextMatch ? bulletTextMatch[1] : line).trim();
+    if (!current) {
+      continue;
+    }
+    if (contentText) {
+      current.content.push(contentText);
+    }
+  }
+
+  flushCurrent();
+  return results.slice(0, numResults);
+}
+
+async function postJson(endpoint, headers, requestBody) {
+  const maxAttempts = 5;
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(function() { controller.abort(); }, 60000);
+
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: headers,
+        body: JSON.stringify(requestBody),
+        signal: controller.signal,
+      });
+      const responseText = await response.text();
+      let payload = {};
+      if (responseText) {
+        try {
+          payload = JSON.parse(responseText);
+        } catch {
+          throw new Error('Invalid JSON response from ' + endpoint);
         }
       }
+
+      if (!response.ok) {
+        const message = extractErrorMessage(payload && payload.error) || ('HTTP ' + response.status);
+        if (attempt < maxAttempts && isRetryableSearchFailure(response.status, message)) {
+          lastError = new Error(message);
+          const delayMs = getRetryDelayMs(attempt);
+          log('Retrying request after upstream error:', response.status, message, '| next attempt', attempt + 1, 'of', maxAttempts);
+          await sleep(delayMs);
+          continue;
+        }
+        throw new Error(message);
+      }
+
+      if (payload && payload.error) {
+        const message = extractErrorMessage(payload.error);
+        if (attempt < maxAttempts && isRetryableSearchFailure(undefined, message)) {
+          lastError = new Error(message);
+          const delayMs = getRetryDelayMs(attempt);
+          log('Retrying request after payload error:', message, '| next attempt', attempt + 1, 'of', maxAttempts);
+          await sleep(delayMs);
+          continue;
+        }
+        throw new Error(message);
+      }
+
+      return payload;
+    } catch (e) {
+      const message = e && e.name === 'AbortError' ? 'Request timed out' : (e && e.message ? e.message : String(e));
+      if (attempt < maxAttempts && isRetryableSearchFailure(undefined, message)) {
+        lastError = new Error(message);
+        const delayMs = getRetryDelayMs(attempt);
+        log('Retrying request after transport error:', message, '| next attempt', attempt + 1, 'of', maxAttempts);
+        await sleep(delayMs);
+        continue;
+      }
+      throw new Error(message);
+    } finally {
+      clearTimeout(timeoutId);
     }
-    
-    log('Results:', results.length);
-    return results.length > 0 ? results.slice(0, numResults) : null;
-  } catch (e) {
-    log('Anthropic error:', e.message);
-    return null;
   }
+
+  throw lastError || new Error('Request failed');
+}
+
+async function searchAnthropicNative(query, numResults, modelConfig) {
+  const endpoint = normalizeEndpoint(modelConfig.baseUrl, '/v1/messages');
+  const requestBody = {
+    model: modelConfig.model,
+    max_tokens: 4096,
+    stream: false,
+    system: 'You are a web search assistant. Use the web_search tool to find relevant information and return the results.',
+    tools: [{ type: 'web_search_20250305', name: 'web_search', max_uses: 1 }],
+    tool_choice: { type: 'tool', name: 'web_search' },
+    messages: [{ role: 'user', content: 'Search the web for: ' + query + '\\n\\nReturn up to ' + numResults + ' relevant results.' }],
+  };
+
+  log('Anthropic search:', query, '→', endpoint);
+  const response = await postJson(endpoint, {
+    'Content-Type': 'application/json',
+    'anthropic-version': '2023-06-01',
+    'x-api-key': modelConfig.apiKey,
+  }, requestBody);
+
+  const results = [];
+  for (const block of (response.content || [])) {
+    if (block.type !== 'web_search_tool_result') continue;
+    for (const result of (block.content || [])) {
+      if (result.type !== 'web_search_result') continue;
+      results.push({
+        title: result.title || '',
+        url: result.url || '',
+        content: result.snippet || result.page_content || '',
+      });
+    }
+  }
+
+  log('Anthropic results:', results.length);
+  return results.slice(0, numResults);
 }
 
 async function searchOpenAINative(query, numResults, modelConfig) {
-  const { baseUrl, apiKey, model } = modelConfig;
-  
-  try {
-    // Note: instructions will be added by openai4droid proxy plugin
-    const requestBody = {
-      model: model,
-      stream: false,
-      tools: [{ type: 'web_search' }],
-      tool_choice: 'required',
-      input: 'Search the web for: ' + query + '\\n\\nReturn up to ' + numResults + ' relevant results.'
-    };
-    
-    let endpoint = baseUrl;
-    if (!endpoint.endsWith('/responses')) endpoint = endpoint.replace(/\\/$/, '') + '/responses';
-    
-    log('OpenAI search:', query, '→', endpoint);
-    
-    const bodyStr = JSON.stringify(requestBody).replace(/'/g, "'\\\\''");
-    const curlCmd = 'curl -s -X POST "' + endpoint + '" -H "Content-Type: application/json" -H "Authorization: Bearer ' + apiKey + '" -d \\'' + bodyStr + "\\'";
-    const responseStr = execSync(curlCmd, { encoding: 'utf-8', timeout: 60000 });
-    
-    let response;
-    try { response = JSON.parse(responseStr); } catch { return null; }
-    if (response.error) { log('API error:', response.error.message); return null; }
-    
-    // Extract results from url_citation annotations in message output
-    const results = [];
-    for (const item of (response.output || [])) {
-      if (item.type === 'message' && Array.isArray(item.content)) {
+  const endpoint = normalizeEndpoint(modelConfig.baseUrl, '/responses');
+  const input = 'Search the web for: ' + query + '\\n\\nReturn up to ' + numResults + ' relevant results.';
+  const requestVariants = [
+    {
+      label: 'web_search',
+      body: {
+        model: modelConfig.model,
+        stream: false,
+        tools: [{ type: 'web_search' }],
+        tool_choice: 'required',
+        input: input,
+      },
+    },
+    {
+      label: 'web_search_preview',
+      body: {
+        model: modelConfig.model,
+        stream: false,
+        tools: [{ type: 'web_search_preview' }],
+        input: input,
+      },
+    },
+  ];
+
+  let lastError = null;
+  for (const variant of requestVariants) {
+    try {
+      log('OpenAI search:', query, '→', endpoint, '(' + variant.label + ')');
+      const response = await postJson(endpoint, {
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer ' + modelConfig.apiKey,
+      }, variant.body);
+
+      const results = [];
+      const textBlocks = [];
+      for (const item of (response.output || [])) {
+        if (item.type !== 'message' || !Array.isArray(item.content)) continue;
         for (const content of item.content) {
-          if (content.type === 'output_text' && Array.isArray(content.annotations)) {
-            for (const annotation of content.annotations) {
-              if (annotation.type === 'url_citation' && annotation.url) {
-                results.push({
-                  title: annotation.title || '',
-                  url: annotation.url || '',
-                  content: annotation.title || ''
-                });
-              }
-            }
+          if (content.type !== 'output_text') continue;
+          if (content.text) {
+            textBlocks.push(content.text);
+          }
+          if (!Array.isArray(content.annotations)) continue;
+          for (const annotation of content.annotations) {
+            if (annotation.type !== 'url_citation' || !annotation.url) continue;
+            pushUniqueResult(results, {
+              title: annotation.title || '',
+              url: annotation.url || '',
+              content: annotation.title || '',
+            });
+          }
+        }
+      }
+
+      if (results.length === 0) {
+        for (const textBlock of textBlocks) {
+          for (const parsedResult of parseOpenAITextResults(textBlock, numResults)) {
+            pushUniqueResult(results, parsedResult);
           }
+          if (results.length >= numResults) break;
         }
       }
+
+      log('OpenAI results:', results.length, 'via', variant.label);
+      return results.slice(0, numResults);
+    } catch (e) {
+      lastError = e;
+      log('OpenAI variant failed:', variant.label, '-', e.message);
     }
-    
-    log('Results:', results.length);
-    return results.length > 0 ? results.slice(0, numResults) : null;
-  } catch (e) {
-    log('OpenAI error:', e.message);
-    return null;
   }
+
+  throw lastError || new Error('OpenAI web search failed');
 }
 
 async function search(query, numResults) {
   numResults = numResults || 10;
   log('Search:', query);
-  
-  const modelConfig = getCurrentModelConfig();
-  if (!modelConfig) {
-    log('No custom model configured');
-    return { results: [], source: 'none' };
+
+  const resolved = getCurrentModelConfig(lastObservedProvider);
+  if (!resolved.modelConfig) {
+    return {
+      results: [],
+      source: 'none',
+      error: resolved.error,
+      statusCode: resolved.statusCode || 400,
+    };
+  }
+
+  try {
+    let results = [];
+    if (resolved.modelConfig.provider === 'anthropic') {
+      results = await searchAnthropicNative(query, numResults, resolved.modelConfig);
+    } else if (resolved.modelConfig.provider === 'openai') {
+      results = await searchOpenAINative(query, numResults, resolved.modelConfig);
+    } else {
+      return {
+        results: [],
+        source: 'none',
+        error: 'Unsupported provider: ' + resolved.modelConfig.provider,
+        statusCode: 400,
+      };
+    }
+
+    return {
+      results: results,
+      source: 'native-' + resolved.modelConfig.provider,
+      modelId: resolved.modelConfig.id,
+    };
+  } catch (e) {
+    return {
+      results: [],
+      source: 'none',
+      error: e && e.message ? e.message : String(e),
+      statusCode: 502,
+    };
   }
-  
-  const provider = modelConfig.provider;
-  let results = null;
-  
-  if (provider === 'anthropic') results = await searchAnthropicNative(query, numResults, modelConfig);
-  else if (provider === 'openai') results = await searchOpenAINative(query, numResults, modelConfig);
-  else log('Unsupported provider:', provider);
-  
-  if (results && results.length > 0) return { results: results, source: 'native-' + provider };
-  return { results: [], source: 'none' };
 }
 
 // === HTTP Proxy Server ===
@@ -469,14 +736,20 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
-  if (url.pathname === '/api/tools/exa/search' && req.method === 'POST') {
+  if (isSearchRequest(url, req.method)) {
     let body = '';
     req.on('data', function(c) { body += c; });
     req.on('end', async function() {
       try {
         const parsed = JSON.parse(body);
         const result = await search(parsed.query, parsed.numResults || 10);
-        log('Results:', result.results.length, 'from', result.source);
+        if (result.error) {
+          log('Search failed:', result.error);
+          res.writeHead(result.statusCode || 500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: result.error, results: [] }));
+          return;
+        }
+        log('Results:', result.results.length, 'from', result.source, 'model', result.modelId || 'unknown');
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ results: result.results }));
       } catch (e) {
@@ -511,6 +784,8 @@ const server = http.createServer(async (req, res) => {
   }
 
   // Simple proxy - no SSE transformation (handled by proxy plugin)
+  if (url.pathname.startsWith('/api/llm/a/')) lastObservedProvider = 'anthropic';
+  if (url.pathname.startsWith('/api/llm/o/')) lastObservedProvider = 'openai';
   log('Proxy:', req.method, url.pathname);
   const proxyUrl = new URL(FACTORY_API + url.pathname + url.search);
   const proxyModule = proxyUrl.protocol === 'https:' ? https : http;
@@ -571,7 +846,7 @@ should_passthrough() {
   for arg in "$@"; do
     if [ "$arg" = "--" ]; then end_opts=1; continue; fi
     if [ "$end_opts" -eq 0 ] && [[ "$arg" == -* ]]; then continue; fi
-    case "$arg" in help|version|completion|completions|exec|plugin) return 0 ;; esac
+    case "$arg" in help|version|completion|completions|plugin) return 0 ;; esac
     break
   done
   return 1
@@ -625,6 +900,9 @@ rm -f "$PORT_FILE"
 
 export FACTORY_API_BASE_URL_OVERRIDE="http://127.0.0.1:$ACTUAL_PORT"
 export FACTORY_API_BASE_URL="http://127.0.0.1:$ACTUAL_PORT"
+export FACTORY_APP_BASE_URL_OVERRIDE="http://127.0.0.1:$ACTUAL_PORT"
+export FACTORY_APP_BASE_URL="http://127.0.0.1:$ACTUAL_PORT"
+export TOOLS_WEBSEARCH_BASE_URL="http://127.0.0.1:$ACTUAL_PORT"
 "$DROID_BIN" "$@"
 DROID_EXIT_CODE=$?
 exit $DROID_EXIT_CODE
@@ -654,7 +932,6 @@ for %%a in (%*) do (
     if "%%a"=="version" set "PASSTHROUGH=1"
     if "%%a"=="completion" set "PASSTHROUGH=1"
     if "%%a"=="completions" set "PASSTHROUGH=1"
-    if "%%a"=="exec" set "PASSTHROUGH=1"
     if "%%a"=="plugin" set "PASSTHROUGH=1"
 )
 if "%PASSTHROUGH%"=="1" (
@@ -708,6 +985,9 @@ del "%PORT_FILE%" 2>nul
 
 set "FACTORY_API_BASE_URL_OVERRIDE=http://127.0.0.1:%ACTUAL_PORT%"
 set "FACTORY_API_BASE_URL=http://127.0.0.1:%ACTUAL_PORT%"
+set "FACTORY_APP_BASE_URL_OVERRIDE=http://127.0.0.1:%ACTUAL_PORT%"
+set "FACTORY_APP_BASE_URL=http://127.0.0.1:%ACTUAL_PORT%"
+set "TOOLS_WEBSEARCH_BASE_URL=http://127.0.0.1:%ACTUAL_PORT%"
 "%DROID_BIN%" %*
 set "DROID_EXIT_CODE=%ERRORLEVEL%"
 
@@ -1061,12 +1341,38 @@ function compareSemver(left, right) {
 	}
 	return 0;
 }
+function regexMatchesText(text, regex) {
+	const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
+	return new RegExp(regex.source, flags).test(text);
+}
+function patchMatchesBinary(binaryBuffer, binaryText, patch) {
+	if (patch.regexPattern) return regexMatchesText(binaryText, patch.regexPattern) || !!patch.alreadyPatchedRegexPattern && regexMatchesText(binaryText, patch.alreadyPatchedRegexPattern);
+	return [{
+		pattern: patch.pattern,
+		replacement: patch.replacement
+	}, ...patch.variants || []].some((variant) => !!variant.pattern.length && binaryBuffer.includes(variant.pattern) || !!variant.replacement.length && binaryBuffer.includes(variant.replacement));
+}
+function inferVersionedPatchRuleFromBinary(droidPath, rules) {
+	if (!droidPath || !existsSync(droidPath)) return;
+	try {
+		const binaryBuffer = readFileSync(droidPath);
+		const binaryText = binaryBuffer.toString("utf-8");
+		const matchingRules = rules.filter((rule) => rule.buildPatches().every((patch) => patchMatchesBinary(binaryBuffer, binaryText, patch)));
+		if (matchingRules.length === 1) return matchingRules[0];
+	} catch {}
+}
 function matchesVersionRule(droidVersion, rule) {
 	if (rule.minVersion && compareSemver(droidVersion, rule.minVersion) < 0) return false;
 	if (rule.maxVersion && compareSemver(droidVersion, rule.maxVersion) >= 0) return false;
 	return true;
 }
-function resolveVersionedPatches(featureName, droidVersion, rules) {
+function resolveVersionedPatches(featureName, droidVersion, rules, droidPath) {
+	if (droidVersion && parseSemver(droidVersion)) {
+		const matchedRule = rules.find((rule) => matchesVersionRule(droidVersion, rule));
+		if (matchedRule) return matchedRule.buildPatches();
+	}
+	const inferredRule = inferVersionedPatchRuleFromBinary(droidPath, rules);
+	if (inferredRule) return inferredRule.buildPatches();
 	if (!droidVersion) throw new Error(`Unable to detect droid version for ${featureName}`);
 	if (!parseSemver(droidVersion)) throw new Error(`Unsupported droid version format "${droidVersion}" for ${featureName}`);
 	const matchedRule = rules.find((rule) => matchesVersionRule(droidVersion, rule));
@@ -1103,6 +1409,40 @@ const SKIP_LOGIN_PATCH_RULES = [{
 		alreadyPatchedRegexPattern: SKIP_LOGIN_V068_PLUS_PATCHED_REGEX
 	}]
 }];
+const FACTORYD_SELF_PATH_REGEX = /(function ([A-Za-z$_][A-Za-z0-9$_]*)\(([A-Za-z$_][A-Za-z0-9$_]*)\)\{if\()([A-Za-z$_][A-Za-z0-9$_]*)\.basename\(process\.execPath\)\.includes\("droid"\)(\)return process\.execPath;return \3\?"droid-dev":"droid"\})/g;
+const FACTORYD_SELF_PATH_PATCHED_REGEX = /function ([A-Za-z$_][A-Za-z0-9$_]*)\(([A-Za-z$_][A-Za-z0-9$_]*)\)\{if\(\(1\|\|([A-Za-z$_][A-Za-z0-9$_]*)\.basename\(process\.execPath\)\.includes\(""\)\)\)return process\.execPath;return \2\?"droid-dev":"droid"\}/g;
+const FACTORYD_SKIP_LOGIN_AUTH_REGEX = /async function ([A-Za-z$_][A-Za-z0-9$_]*)\(([A-Za-z$_][A-Za-z0-9$_]*)\)\{let ([A-Za-z$_][A-Za-z0-9$_]*)=([A-Za-z$_][A-Za-z0-9$_]*)\(\)\.apiBaseUrl,([A-Za-z$_][A-Za-z0-9$_]*)=await fetch\(`\$\{\3\}\/api\/cli\/whoami`,\{method:"GET",headers:\{Authorization:`Bearer \$\{\2\}`\}\}\),([A-Za-z$_][A-Za-z0-9$_]*)=await \5\.text\(\);if\(!\5\.ok\)throw new ([A-Za-z$_][A-Za-z0-9$_]*)\("API key verification failed",\{statusCode:\5\.status,body:\6\}\);let ([A-Za-z$_][A-Za-z0-9$_]*)=([A-Za-z$_][A-Za-z0-9$_]*)\(\6,([A-Za-z$_][A-Za-z0-9$_]*),"whoami response"\);return\{userId:\8\.userId,email:"",orgId:\8\.orgId\}\}/g;
+const FACTORYD_SKIP_LOGIN_AUTH_PATCHED_REGEX = /async function [A-Za-z$_][A-Za-z0-9$_]*\(([A-Za-z$_][A-Za-z0-9$_]*)\)\{if\(\/\^fk\/\.test\(\1\)\)return\{userId:"f",orgId:"f"\};let ([A-Za-z$_][A-Za-z0-9$_]*)=await fetch\(`\$\{([A-Za-z$_][A-Za-z0-9$_]*)\(\)\.apiBaseUrl\}\/api\/cli\/whoami`,\{headers:\{Authorization:`Bearer \$\{\1\}`\}\}\);if\(!\2\.ok\)throw new [A-Za-z$_][A-Za-z0-9$_]*\("API key verification failed"\);\2=[A-Za-z$_][A-Za-z0-9$_]*\(await \2\.text\(\),([A-Za-z$_][A-Za-z0-9$_]*),"whoami response"\);return\{userId:\2\.userId,email:"",orgId:\2\.orgId\}\s+\}/g;
+function createFactorydSelfPathPatch() {
+	return {
+		name: "factorydSelfPath",
+		description: "Force factoryd auto-start to reuse the current executable instead of falling back to plain droid",
+		pattern: Buffer.from(""),
+		replacement: Buffer.from(""),
+		regexPattern: FACTORYD_SELF_PATH_REGEX,
+		regexReplacement: "$1(1||$4.basename(process.execPath).includes(\"\"))$5",
+		alreadyPatchedRegexPattern: FACTORYD_SELF_PATH_PATCHED_REGEX
+	};
+}
+function createFactorydSkipLoginAuthPatch() {
+	return {
+		name: "factorydSkipLoginAuth",
+		description: "Allow mission/factoryd auth to reuse fk- API key sessions via the shared /api/cli/whoami helper",
+		pattern: Buffer.from(""),
+		replacement: Buffer.from(""),
+		regexPattern: FACTORYD_SKIP_LOGIN_AUTH_REGEX,
+		regexReplacement: "async function $1($2){if(/^fk/.test($2))return{userId:\"f\",orgId:\"f\"};let $3=await fetch(`${$4().apiBaseUrl}/api/cli/whoami`,{headers:{Authorization:`Bearer ${$2}`}});if(!$3.ok)throw new $7(\"API key verification failed\");$3=$9(await $3.text(),$10,\"whoami response\");return{userId:$3.userId,email:\"\",orgId:$3.orgId}        }",
+		alreadyPatchedRegexPattern: FACTORYD_SKIP_LOGIN_AUTH_PATCHED_REGEX
+	};
+}
+function needsBinaryPatches(config) {
+	return config.isCustom || config.skipLogin || config.reasoningEffort || !!config.noTelemetry || !!config.apiBase && !config.websearch && !config.websearchProxy;
+}
+function createMissionFactorydPatches(config) {
+	const patches = [createFactorydSelfPathPatch()];
+	if (config.skipLogin) patches.push(createFactorydSkipLoginAuthPatch());
+	return patches;
+}
 function findDefaultDroidPath() {
 	const home = homedir();
 	if (IS_WINDOWS) {
@@ -1126,19 +1466,20 @@ function findDefaultDroidPath() {
 		for (const p of windowsPaths) if (existsSync(p)) return p;
 		return join(home, ".droid", "bin", "droid.exe");
 	}
-	try {
-		const result = execSync("which droid", {
+	for (const lookupCommand of ["command -v droid", "which droid"]) try {
+		const firstResult = execSync(lookupCommand, {
 			encoding: "utf-8",
 			stdio: [
 				"pipe",
 				"pipe",
 				"pipe"
 			]
-		}).trim();
-		if (result && existsSync(result)) return result;
+		}).trim().split(/\r?\n/)[0];
+		if (firstResult && existsSync(firstResult)) return firstResult;
 	} catch {}
 	const paths = [
 		join(home, ".droid", "bin", "droid"),
+		join(home, ".local", "bin", "droid"),
 		"/opt/homebrew/bin/droid",
 		"/usr/local/bin/droid",
 		"/usr/bin/droid",
@@ -1165,7 +1506,15 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 	const verbose = options.verbose;
 	const droidVersion = getDroidVersion(path);
 	const outputPath = outputDir && alias ? join(outputDir, alias) : void 0;
-	const needsBinaryPatch = !!isCustom || !!skipLogin || !!reasoningEffort || !!noTelemetry || !!apiBase && !websearch && !websearchProxy;
+	const needsBinaryPatch = needsBinaryPatches({
+		isCustom: !!isCustom,
+		skipLogin: !!skipLogin,
+		apiBase,
+		websearch: !!websearch,
+		websearchProxy: !!websearchProxy,
+		reasoningEffort: !!reasoningEffort,
+		noTelemetry: !!noTelemetry
+	});
 	if (websearch && websearchProxy) {
 		console.log(styleText("red", "Error: Cannot use --websearch and --websearch-proxy together"));
 		console.log(styleText("gray", "Choose one:"));
@@ -1284,7 +1633,7 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 	console.log(styleText(["cyan", "bold"], "  Droid Binary Patcher"));
 	console.log(styleText("cyan", "═".repeat(60)));
 	console.log();
-	const patches = [];
+	const patches = createMissionFactorydPatches({ skipLogin });
 	if (isCustom) patches.push({
 		name: "isCustom",
 		description: "Change isCustom:!0 to isCustom:!1",
@@ -1292,7 +1641,7 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 		replacement: Buffer.from("isCustom:!1")
 	});
 	if (skipLogin) try {
-		patches.push(...resolveVersionedPatches("--skip-login", droidVersion, SKIP_LOGIN_PATCH_RULES));
+		patches.push(...resolveVersionedPatches("--skip-login", droidVersion, SKIP_LOGIN_PATCH_RULES, path));
 	} catch (error) {
 		console.log(styleText("red", `Error: ${error.message}`));
 		if (!droidVersion) console.log(styleText("gray", "Please use -p to point to a runnable droid binary."));
@@ -1431,8 +1780,7 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 			console.log(styleText(["blue", "bold"], "  DRY RUN COMPLETE"));
 			console.log(styleText("blue", "═".repeat(60)));
 			console.log();
-			console.log(styleText("gray", "To apply the patches, run without --dry-run:"));
-			console.log(styleText("cyan", `  npx droid-patch --is-custom ${alias || "<alias-name>"}`));
+			console.log(styleText("gray", "To apply the patches, rerun the same command without --dry-run."));
 			process.exit(0);
 		}
 		if (outputDir && result.success && result.outputPath) {
@@ -1596,14 +1944,14 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 			continue;
 		}
 		try {
-			const patches = [];
+			const patches = needsBinaryPatches(meta.patches) ? createMissionFactorydPatches({ skipLogin: meta.patches.skipLogin }) : [];
 			if (meta.patches.isCustom) patches.push({
 				name: "isCustom",
 				description: "Change isCustom:!0 to isCustom:!1",
 				pattern: Buffer.from("isCustom:!0"),
 				replacement: Buffer.from("isCustom:!1")
 			});
-			if (meta.patches.skipLogin) patches.push(...resolveVersionedPatches("skip-login", newDroidVersion, SKIP_LOGIN_PATCH_RULES));
+			if (meta.patches.skipLogin) patches.push(...resolveVersionedPatches("skip-login", newDroidVersion, SKIP_LOGIN_PATCH_RULES, newBinaryPath));
 			if (meta.patches.apiBase && !meta.patches.websearch) {
 				const originalUrl = "https://api.factory.ai";
 				const paddedUrl = meta.patches.apiBase.padEnd(22, " ");
@@ -1732,9 +2080,9 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 				}
 			}
 			let execTargetPath = patches.length > 0 ? outputPath : newBinaryPath;
-			if (meta.patches.websearch || !!meta.patches.proxy) {
+			if (meta.patches.websearch || !!meta.patches.websearchProxy || !!meta.patches.proxy) {
 				const forwardTarget = meta.patches.apiBase || meta.patches.proxy || "https://api.factory.ai";
-				const { wrapperScript } = await createWebSearchUnifiedFiles(join(homedir(), ".droid-patch", "proxy"), execTargetPath, meta.name, forwardTarget, meta.patches.standalone || false);
+				const { wrapperScript } = await createWebSearchUnifiedFiles(join(homedir(), ".droid-patch", "proxy"), execTargetPath, meta.name, forwardTarget, meta.patches.standalone || false, meta.patches.websearchProxy || false);
 				execTargetPath = wrapperScript;
 				if (verbose) {
 					console.log(styleText("gray", `  Regenerated websearch wrapper`));