neoagent 2.3.1-beta.111 → 2.3.1-beta.114

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.111",
+  "version": "2.3.1-beta.114",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-9ad3e5040ffa79037fb5bea961ce891c
+d24ae5d149080cae1dd694a9d7d1cca7

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"42d3d75a56efe1a2e9902f52dc8006099c45d9
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1758267936" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "2783772789" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -129338,7 +129338,7 @@ r===$&&A.b()
 o.push(A.ii(p,A.iY(!1,new A.a3(B.tM,A.dT(new A.cI(B.he,new A.a5V(r,p),p),p,p),p),!1,B.I,!0),p,p,0,0,0,p))}r=!1
 if(!s.ay)if(!s.ch){r=s.e
 r===$&&A.b()
-r=B.b.t("mpb2pck6-950cc89").length!==0&&r.b}if(r){r=s.d
+r=B.b.t("mpb91fkt-6e44b2b").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.ag&&!r.V?84:0
 q=s.e
@@ -134146,7 +134146,7 @@ $S:236}
 A.Ys.prototype={}
 A.Rr.prototype={
 mT(a){var s=this
-if(B.b.t("mpb2pck6-950cc89").length===0||s.a!=null)return
+if(B.b.t("mpb91fkt-6e44b2b").length===0||s.a!=null)return
 s.A5()
 s.a=A.q1(B.PP,new A.b58(s))},
 A5(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -134164,7 +134164,7 @@ if(!t.f.b(k)){s=1
 break}i=J.Z(k,"buildId")
 h=i==null?null:B.b.t(J.r(i))
 j=h==null?"":h
-if(J.bm(j)===0||J.d(j,"mpb2pck6-950cc89")){s=1
+if(J.bm(j)===0||J.d(j,"mpb91fkt-6e44b2b")){s=1
 break}n.b=!0
 n.D()
 p=2
@@ -134181,7 +134181,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$A5,r)},
 vb(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$vb=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.t("mpb2pck6-950cc89").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.t("mpb91fkt-6e44b2b").length===0||n.c){s=1
 break}n.c=!0
 n.D()
 p=4

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

@@ -5,17 +5,143 @@ const Anthropic = require('@anthropic-ai/sdk');
 const { AnthropicProvider } = require('./anthropic');
 
 const CLAUDE_CLI_CREDS_PATH = path.join(os.homedir(), '.claude', '.credentials.json');
-const CLAUDE_CODE_BASE_URL = 'https://api.claude.ai/api';
+const CLAUDE_CODE_BASE_URL = 'https://api.anthropic.com';
+const CLAUDE_CODE_VERSION = process.env.CLAUDE_CODE_VERSION || '2.1.75';
+const CLAUDE_CODE_OAUTH_BETA = 'claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14';
+const CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
+const CLAUDE_CODE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const CLAUDE_CODE_TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
 
-function readClaudeCliToken() {
+function readTokenRecord(data) {
+  const tokens = data?.claudeAiOauthTokens || data?.claudeAiOauth || {};
+  const access = tokens.accessToken || tokens.access;
+  const refresh = tokens.refreshToken || tokens.refresh;
+  const expires = tokens.expiresAt || tokens.expires;
+  return {
+    access: typeof access === 'string' && access ? access : null,
+    refresh: typeof refresh === 'string' && refresh ? refresh : null,
+    expires: typeof expires === 'number' && Number.isFinite(expires) ? expires : null,
+  };
+}
+
+function readTokenValue(data) {
+  return readTokenRecord(data).access;
+}
+
+function readClaudeCliTokenRecord() {
   try {
     const raw = fs.readFileSync(CLAUDE_CLI_CREDS_PATH, 'utf8');
     const data = JSON.parse(raw);
-    const token = data?.claudeAiOauthTokens?.accessToken;
-    return typeof token === 'string' && token ? token : null;
+    return readTokenRecord(data);
+  } catch {
+    return { access: null, refresh: null, expires: null };
+  }
+}
+
+function readClaudeCliToken() {
+  return readClaudeCliTokenRecord().access;
+}
+
+function mergeAnthropicBeta(existing) {
+  if (!existing) return CLAUDE_CODE_OAUTH_BETA;
+  const seen = new Set();
+  return String(existing)
+    .split(',')
+    .concat(CLAUDE_CODE_OAUTH_BETA.split(','))
+    .map((item) => item.trim())
+    .filter((item) => {
+      if (!item || seen.has(item)) return false;
+      seen.add(item);
+      return true;
+    })
+    .join(',');
+}
+
+function normalizeExpiresAt(data) {
+  if (typeof data.expires_at === 'number' && Number.isFinite(data.expires_at)) {
+    return data.expires_at > 10_000_000_000 ? data.expires_at : data.expires_at * 1000;
+  }
+  if (typeof data.expiresAt === 'number' && Number.isFinite(data.expiresAt)) {
+    return data.expiresAt > 10_000_000_000 ? data.expiresAt : data.expiresAt * 1000;
+  }
+  if (typeof data.expires_in === 'number' && Number.isFinite(data.expires_in)) {
+    return Date.now() + (data.expires_in * 1000);
+  }
+  return null;
+}
+
+function sanitizeEnvKey(key) {
+  return String(key).replace(/[\r\n]/g, '');
+}
+
+function sanitizeEnvValue(value) {
+  return String(value).replace(/[\r\n]/g, '');
+}
+
+function persistEnvValue(key, value) {
+  if (!value) return;
+  try {
+    const { ENV_FILE } = require('../../../../runtime/paths');
+    const safeKey = sanitizeEnvKey(key);
+    const safeValue = sanitizeEnvValue(value);
+    const raw = fs.existsSync(ENV_FILE) ? fs.readFileSync(ENV_FILE, 'utf8') : '';
+    const lines = raw ? raw.split('\n') : [];
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith(`${safeKey}=`)) {
+        lines[i] = `${safeKey}=${safeValue}`;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) lines.push(`${safeKey}=${safeValue}`);
+    const output = lines.filter((_, idx, arr) => idx !== arr.length - 1 || arr[idx] !== '').join('\n') + '\n';
+    fs.mkdirSync(path.dirname(ENV_FILE), { recursive: true });
+    fs.writeFileSync(ENV_FILE, output, { mode: 0o600 });
+  } catch { }
+}
+
+async function refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch) {
+  if (!refreshToken) return null;
+  const response = await fetchImpl(CLAUDE_CODE_TOKEN_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: CLAUDE_CODE_CLIENT_ID,
+    }),
+  });
+
+  const text = await response.text();
+  let data = {};
+  try {
+    data = text ? JSON.parse(text) : {};
   } catch {
-    return null;
+    data = {};
   }
+
+  if (!response.ok) {
+    const detail = data?.error?.message || data?.error_description || data?.error || text || 'Unknown error';
+    throw new Error(`Claude Code OAuth refresh failed: HTTP ${response.status} ${detail}`);
+  }
+  if (!data.access_token) {
+    throw new Error('Claude Code OAuth refresh succeeded but no access_token was returned.');
+  }
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || refreshToken,
+    expires: normalizeExpiresAt(data),
+  };
+}
+
+function isAuthenticationError(err) {
+  return err?.status === 401 || err?.error?.type === 'authentication_error';
 }
 
 class ClaudeCodeProvider extends AnthropicProvider {
@@ -33,17 +159,86 @@ class ClaudeCodeProvider extends AnthropicProvider {
       'claude-haiku-4-5-20251001': 200000,
     };
 
-    const authToken = config.apiKey || process.env.CLAUDE_CODE_OAUTH_TOKEN || readClaudeCliToken();
+    const cliTokenRecord = readClaudeCliTokenRecord();
+    const authToken = config.apiKey || process.env.CLAUDE_CODE_OAUTH_TOKEN || cliTokenRecord.access;
     if (!authToken) {
       console.warn('[ClaudeCode] No access token. Run `neoagent login claude-code` to authenticate.');
     }
 
-    // OAuth tokens use Authorization: Bearer — authToken option sends that header
-    this.client = new Anthropic({
+    this.authToken = authToken || null;
+    this.refreshToken = config.refreshToken || process.env.CLAUDE_CODE_REFRESH_TOKEN || cliTokenRecord.refresh || null;
+    this.fetchImpl = config.fetch || fetch;
+    this.baseURL = config.baseUrl || CLAUDE_CODE_BASE_URL;
+    this.defaultHeaders = {
+      ...(config.defaultHeaders || {}),
+      accept: 'application/json',
+      'anthropic-dangerous-direct-browser-access': 'true',
+      'anthropic-beta': mergeAnthropicBeta(config.defaultHeaders?.['anthropic-beta']),
+      'user-agent': `claude-cli/${CLAUDE_CODE_VERSION}`,
+      'x-app': 'cli',
+    };
+
+    this.client = this.createClient(this.authToken, config);
+  }
+
+  createClient(authToken, config = this.config) {
+    // OAuth tokens use Authorization: Bearer. Claude Code subscription inference
+    // also requires the Claude Code beta surface headers used by the official CLI.
+    return new Anthropic({
       authToken: authToken || undefined,
-      baseURL: config.baseUrl || CLAUDE_CODE_BASE_URL,
+      baseURL: this.baseURL,
+      defaultHeaders: authToken ? this.defaultHeaders : config.defaultHeaders,
+      ...(this.fetchImpl ? { fetch: this.fetchImpl } : {}),
     });
   }
+
+  async refreshClient() {
+    const refreshed = await refreshClaudeCodeAccessToken(this.refreshToken, this.fetchImpl);
+    if (!refreshed?.access) return false;
+    this.authToken = refreshed.access;
+    this.refreshToken = refreshed.refresh || this.refreshToken;
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = this.authToken;
+    persistEnvValue('CLAUDE_CODE_OAUTH_TOKEN', this.authToken);
+    if (this.refreshToken) {
+      process.env.CLAUDE_CODE_REFRESH_TOKEN = this.refreshToken;
+      persistEnvValue('CLAUDE_CODE_REFRESH_TOKEN', this.refreshToken);
+    }
+    this.client = this.createClient(this.authToken);
+    return true;
+  }
+
+  convertMessages(messages) {
+    const converted = super.convertMessages(messages);
+    if (!converted.system) {
+      converted.system = [{ type: 'text', text: CLAUDE_CODE_SYSTEM_PROMPT }];
+      return converted;
+    }
+    converted.system = [
+      { type: 'text', text: CLAUDE_CODE_SYSTEM_PROMPT },
+      { type: 'text', text: converted.system },
+    ];
+    return converted;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    try {
+      return await super.chat(messages, tools, options);
+    } catch (err) {
+      if (!isAuthenticationError(err) || !this.refreshToken) throw err;
+      await this.refreshClient();
+      return await super.chat(messages, tools, options);
+    }
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    try {
+      yield* super.stream(messages, tools, options);
+    } catch (err) {
+      if (!isAuthenticationError(err) || !this.refreshToken) throw err;
+      await this.refreshClient();
+      yield* super.stream(messages, tools, options);
+    }
+  }
 }
 
-module.exports = { ClaudeCodeProvider, readClaudeCliToken };
+module.exports = { ClaudeCodeProvider, readClaudeCliToken, refreshClaudeCodeAccessToken };

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

@@ -3,6 +3,14 @@ const OpenAI = require('openai');
 const { BaseProvider } = require('./base');
 
 const DEFAULT_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+const OPENAI_CODEX_EMPTY_INPUT_TEXT = ' ';
+const NEOAGENT_VERSION = (() => {
+  try {
+    return require('../../../../package.json').version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+})();
 
 // Stable per-process installation ID — Codex backend uses it for request tracking.
 const INSTALLATION_ID = crypto.randomUUID();
@@ -26,7 +34,7 @@ function isCodexBackendBaseUrl(baseURL) {
     const url = new URL(trimmed);
     const path = url.pathname.replace(/\/+$/, '');
     return url.hostname === 'chatgpt.com'
-      && (path === '/backend-api' || path === '/backend-api/codex' || path === '/backend-api/codex/v1');
+      && (path === '/backend-api' || path === '/backend-api/v1' || path === '/backend-api/codex' || path === '/backend-api/codex/v1');
   } catch {
     return false;
   }
@@ -52,6 +60,10 @@ function normalizeCodexBaseUrl(baseURL) {
   return baseURL;
 }
 
+function isNativeCodexResponsesBaseUrl(baseURL) {
+  return isCodexBackendBaseUrl(baseURL);
+}
+
 function normalizeContent(content) {
   if (content == null) return '';
   if (typeof content === 'string') return content;
@@ -67,33 +79,45 @@ function normalizeContent(content) {
   return String(content);
 }
 
-function normalizeInputContent(content) {
+function normalizeMessageContent(content, role = 'user') {
   if (content == null) return [];
+  const isAssistant = role === 'assistant';
+  const textType = isAssistant ? 'output_text' : 'input_text';
 
   if (typeof content === 'string') {
-    return [{ type: 'input_text', text: content }];
+    return [{ type: textType, text: content, ...(isAssistant ? { annotations: [] } : {}) }];
   }
 
   if (!Array.isArray(content)) {
     const text = String(content);
-    return text ? [{ type: 'input_text', text }] : [];
+    return text ? [{ type: textType, text, ...(isAssistant ? { annotations: [] } : {}) }] : [];
   }
 
   const parts = [];
   for (const part of content) {
     if (!part) continue;
     if (typeof part === 'string') {
-      if (part.trim()) parts.push({ type: 'input_text', text: part });
+      if (part.trim()) parts.push({ type: textType, text: part, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
     if (part.type === 'text' && typeof part.text === 'string') {
-      parts.push({ type: 'input_text', text: part.text });
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
     if (part.type === 'input_text' && typeof part.text === 'string') {
-      parts.push({ type: 'input_text', text: part.text });
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: [] } : {}) });
+      continue;
+    }
+    if (part.type === 'output_text' && typeof part.text === 'string') {
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: part.annotations || [] } : {}) });
       continue;
     }
+    if (isAssistant && part.type === 'refusal') {
+      const refusal = typeof part.refusal === 'string' ? part.refusal : part.text;
+      if (typeof refusal === 'string') parts.push({ type: 'refusal', refusal });
+      continue;
+    }
+    if (isAssistant) continue;
     if (part.type === 'image_url') {
       const imageUrl = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url;
       if (imageUrl) {
@@ -211,11 +235,9 @@ class OpenAICodexProvider extends BaseProvider {
 
     const defaultHeaders = this.usesCodexBackend
       ? {
-          // Required by Cloudflare bot detection on chatgpt.com
-          'originator': 'Codex Desktop',
-          'User-Agent': 'Codex Desktop/1.0.0 (darwin; arm64)',
-          // Required by the Codex responses endpoint
-          'OpenAI-Beta': 'responses_websockets=2026-02-06',
+          'originator': 'openclaw',
+          'version': NEOAGENT_VERSION,
+          'User-Agent': `openclaw/${NEOAGENT_VERSION}`,
           'x-codex-installation-id': INSTALLATION_ID,
           'x-openai-internal-codex-residency': process.env.OPENAI_CODEX_RESIDENCY || 'us',
           ...(accountId ? { 'ChatGPT-Account-Id': accountId } : {}),
@@ -226,6 +248,7 @@ class OpenAICodexProvider extends BaseProvider {
       apiKey: config.apiKey || process.env.OPENAI_CODEX_ACCESS_TOKEN,
       baseURL,
       defaultHeaders,
+      ...(config.fetch ? { fetch: config.fetch } : {}),
     });
   }
 
@@ -267,11 +290,12 @@ class OpenAICodexProvider extends BaseProvider {
         continue;
       }
 
-      const content = normalizeInputContent(msg.content);
+      const role = msg.role === 'assistant' ? 'assistant' : 'user';
+      const content = normalizeMessageContent(msg.content, role);
       if (content.length > 0) {
         input.push({
           type: 'message',
-          role: msg.role === 'assistant' ? 'assistant' : 'user',
+          role,
           content,
         });
       }
@@ -297,6 +321,13 @@ class OpenAICodexProvider extends BaseProvider {
     };
 
     if (this.usesCodexBackend) {
+      if (input.length === 0 && instructions.length > 0) {
+        input.push({
+          type: 'message',
+          role: 'user',
+          content: [{ type: 'input_text', text: OPENAI_CODEX_EMPTY_INPUT_TEXT }],
+        });
+      }
       // instructions must always be present (even empty) — backend returns 400 if omitted
       request.instructions = instructions.join('\n\n');
       request.store = false;
@@ -315,6 +346,7 @@ class OpenAICodexProvider extends BaseProvider {
         request.reasoning = { effort, summary: 'auto' };
         request.include = ['reasoning.encrypted_content'];
       }
+      this._sanitizeNativeCodexRequest(request);
     } else {
       if (instructions.length > 0) {
         request.instructions = instructions.join('\n\n');
@@ -337,12 +369,63 @@ class OpenAICodexProvider extends BaseProvider {
   }
 
   _requestHeaders() {
+    const requestId = crypto.randomUUID();
     return this.usesCodexBackend
-      ? { 'x-client-request-id': crypto.randomUUID() }
+      ? {
+          'x-client-request-id': requestId,
+          'x-openclaw-session-id': requestId,
+          'x-openclaw-turn-id': requestId,
+          'x-openclaw-turn-attempt': '1',
+        }
       : undefined;
   }
 
+  _sanitizeNativeCodexRequest(request) {
+    if (!isNativeCodexResponsesBaseUrl(this.baseURL)) return request;
+    for (const key of [
+      'max_output_tokens',
+      'metadata',
+      'prompt_cache_retention',
+      'service_tier',
+      'temperature',
+      'top_p',
+    ]) {
+      delete request[key];
+    }
+    if (request.text && typeof request.text === 'object' && !Array.isArray(request.text)) {
+      const text = { ...request.text };
+      delete text.format;
+      if (Object.keys(text).length > 0) {
+        request.text = text;
+      } else {
+        delete request.text;
+      }
+    }
+    return request;
+  }
+
   async chat(messages, tools = [], options = {}) {
+    if (this.usesCodexBackend) {
+      let final = null;
+      let content = '';
+      for await (const event of this.stream(messages, tools, options)) {
+        if (event.type === 'content') {
+          content += event.content || '';
+          continue;
+        }
+        if (event.type === 'tool_calls' || event.type === 'done') {
+          final = event;
+        }
+      }
+      return {
+        content: final?.content || content,
+        toolCalls: final?.toolCalls || [],
+        finishReason: final?.finishReason || (final?.toolCalls?.length > 0 ? 'tool_calls' : 'stop'),
+        usage: final?.usage || null,
+        model: final?.model || options.model || this.config.model || this.getDefaultModel(),
+      };
+    }
+
     const model = options.model || this.config.model || this.getDefaultModel();
     const request = this._buildRequest(messages, tools, options, model);
     let response;