@autotask/atools-tool 0.1.7 → 0.1.9

package/README.md

@@ -31,6 +31,8 @@ Selection UX:
 - TTY terminal: use `↑/↓` and `Enter`
 - Non-TTY: falls back to number input
 
+If proxy startup fails during `atools-tool openclaw`, the CLI now prints environment-aware troubleshooting hints (systemd user bus, permissions, port readiness) and does not silently fail.
+
 Rollback to codex-compatible defaults:
 
 ```bash
@@ -64,7 +66,7 @@ atools-tool-install --help
 
 `atools-tool-install` service behavior by platform:
 
-- Linux: systemd user service
+- Linux: systemd user service (fallback to detached process if `systemctl --user` is unavailable)
 - macOS: launchd user agent (`~/Library/LaunchAgents`)
 - Windows: Task Scheduler user task (ONLOGON + start now)
 
@@ -98,6 +100,7 @@ curl -fsSL https://raw.githubusercontent.com/aak1247/sub2api-openclaw-proxy/main
 - patches `~/.openclaw/agents/main/agent/auth-profiles.json` (if API key is available)
 - service install by platform:
   - Linux: creates/enables `~/.config/systemd/user/openclaw-atools-proxy.service`
+    - if user bus/systemd is unavailable (for example container/root without login bus), installer auto-falls back to detached proxy process
   - macOS: creates/enables `~/Library/LaunchAgents/openclaw-atools-proxy.plist`
   - Windows: creates/updates scheduled task `openclaw-atools-proxy`
 - restarts `openclaw-gateway.service` only on Linux (unless `--no-restart`)

package/lib/config-openclaw.mjs

@@ -296,9 +296,22 @@ function isLinuxProxyServiceActive() {
 
 function startLinuxProxyService() {
   const reload = runSystemctl(['daemon-reload']);
-  if (reload.status !== 0) return false;
+  if (reload.status !== 0) {
+    return {
+      ok: false,
+      step: 'daemon-reload',
+      detail: String(reload.stderr || reload.stdout || '').trim()
+    };
+  }
   const start = runSystemctl(['enable', '--now', PROXY_SERVICE]);
-  return start.status === 0;
+  if (start.status !== 0) {
+    return {
+      ok: false,
+      step: 'enable-start',
+      detail: String(start.stderr || start.stdout || '').trim()
+    };
+  }
+  return { ok: true, step: 'enable-start', detail: '' };
 }
 
 function startDetachedProxy() {
@@ -350,6 +363,31 @@ async function isPortOpen(host, port, timeoutMs = 900) {
   });
 }
 
+function buildProxyTroubleshootingHints({ linuxSystemdError } = {}) {
+  const hints = [];
+  const err = String(linuxSystemdError || '');
+
+  if (/Failed to connect to bus|No medium found/i.test(err)) {
+    hints.push('当前环境没有可用的 systemd 用户会话（常见于容器、root、无登录会话）。');
+    hints.push('建议：直接重新执行 `atools-tool-install`，新版会自动降级到非-systemd进程模式。');
+    hints.push('如果是容器环境，请确保进程管理策略允许后台常驻进程。');
+    return hints;
+  }
+
+  if (/permission denied|access denied/i.test(err)) {
+    hints.push('权限不足，无法通过 systemd --user 启动服务。');
+    hints.push('建议：使用普通登录用户执行安装与配置，不要混用 root 与普通用户的 OpenClaw 目录。');
+    return hints;
+  }
+
+  if (err) {
+    hints.push(`systemd 启动失败：${err}`);
+  }
+  hints.push('建议：检查 OpenClaw Home 路径与 Node 可执行路径是否存在且可访问。');
+  hints.push(`建议：确认端口 ${PROXY_PORT} 未被防火墙或策略阻断。`);
+  return hints;
+}
+
 async function ensureProxyReady() {
   if (process.platform === 'linux') {
     const service = configureLinuxProxyService();
@@ -360,13 +398,13 @@ async function ensureProxyReady() {
     }
   }
 
-  if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return true;
+  if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return { ok: true, mode: 'already-running' };
 
   // Linux retry: service may exist but not running.
   if (process.platform === 'linux') {
     const service = configureLinuxProxyService();
     if (service.exists && isLinuxProxyServiceActive()) {
-      if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return true;
+      if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return { ok: true, mode: 'already-running' };
     }
   }
 
@@ -388,26 +426,45 @@ async function ensureProxyReady() {
   }
 
   if (action === '取消并退出') {
-    return false;
+    return { ok: false, reason: 'user-cancelled', hints: [] };
   }
 
   let started = false;
+  let linuxSystemdError = '';
   if (process.platform === 'linux') {
-    started = startLinuxProxyService();
+    const systemdStart = startLinuxProxyService();
+    started = systemdStart.ok;
+    linuxSystemdError = systemdStart.detail || '';
   }
+  let mode = 'systemd';
   if (!started) {
     started = startDetachedProxy();
+    mode = 'detached';
   }
 
-  if (!started) return false;
+  if (!started) {
+    return {
+      ok: false,
+      reason: 'start-failed',
+      hints: buildProxyTroubleshootingHints({ linuxSystemdError })
+    };
+  }
 
   for (let i = 0; i < 5; i += 1) {
     await sleep(500);
     if (await isPortOpen(PROXY_HOST, PROXY_PORT)) {
-      return true;
+      return { ok: true, mode };
     }
   }
-  return false;
+  return {
+    ok: false,
+    reason: 'port-not-open',
+    hints: [
+      '代理进程启动后端口仍未就绪。',
+      `请检查日志：${PROXY_LOG_FILE}`,
+      '如为受限环境（容器/最小系统），请确认允许本地监听 127.0.0.1。'
+    ]
+  };
 }
 
 function printRestartHint() {
@@ -442,11 +499,18 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
     process.stdout.write(`固定代理目标: ${PROXY_UPSTREAM}\n`);
     process.stdout.write(`固定 Provider Base URL: ${PROXY_BASE_URL}\n`);
 
-    const proxyReady = await ensureProxyReady();
-    if (!proxyReady) {
-      process.stdout.write('\n已取消：本地代理未就绪，未修改 OpenClaw 模型配置。\n');
+    const proxyStatus = await ensureProxyReady();
+    if (!proxyStatus.ok) {
+      process.stdout.write('\n本地代理未就绪，未修改 OpenClaw 模型配置。\n');
+      if (Array.isArray(proxyStatus.hints) && proxyStatus.hints.length > 0) {
+        process.stdout.write('可行解决方案:\n');
+        proxyStatus.hints.forEach((hint) => process.stdout.write(`- ${hint}\n`));
+      }
       return;
     }
+    if (proxyStatus.mode === 'detached') {
+      process.stdout.write('\n已通过非-systemd模式启动代理（兼容无 user bus 环境）。\n');
+    }
     rl = readlinePromises.createInterface({
       input: process.stdin,
       output: process.stdout

package/lib/install.mjs

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const DEFAULT_PROVIDER = 'sub2api';
@@ -350,7 +350,56 @@ function runSystemctl(args, { dryRun } = {}) {
   execFileSync('systemctl', ['--user', ...args], { stdio: 'inherit' });
 }
 
-function installLinuxService({ serviceName, content, dryRun }) {
+function printSystemdFallbackHints(detail) {
+  const text = String(detail || '');
+  if (/Failed to connect to bus|No medium found/i.test(text)) {
+    info('detected: no systemd user bus in current environment');
+    info('hint: this is common in containers/root/non-login sessions');
+    info('hint: installer will continue with detached process mode');
+    return;
+  }
+  if (/permission denied|access denied/i.test(text)) {
+    info('detected: permission issue for systemd --user');
+    info('hint: run install under the same normal user as OpenClaw');
+    info('hint: installer will continue with detached process mode');
+    return;
+  }
+  info('detected: systemd --user is not usable in current environment');
+  info('hint: installer will continue with detached process mode');
+}
+
+function startDetachedProxyProcess({ nodeBin, cliPath, serveArgs, dryRun }) {
+  if (dryRun) {
+    info(`dry-run: detached start ${[nodeBin, cliPath, ...serveArgs].join(' ')}`);
+    return true;
+  }
+  try {
+    const child = spawn(nodeBin, [cliPath, ...serveArgs], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: os.homedir(),
+      env: {
+        ...process.env,
+        HOME: process.env.HOME || os.homedir(),
+        TMPDIR: process.env.TMPDIR || '/tmp',
+        SUB2API_COMPAT_USER_AGENT: 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal'
+      }
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installLinuxService({
+  serviceName,
+  content,
+  nodeBin,
+  cliPath,
+  serveArgs,
+  dryRun
+}) {
   const serviceDir = path.join(os.homedir(), '.config/systemd/user');
   const servicePath = path.join(serviceDir, serviceName);
   ensureDir(serviceDir);
@@ -366,8 +415,22 @@ function installLinuxService({ serviceName, content, dryRun }) {
     info(`wrote: ${servicePath}`);
   }
 
-  runSystemctl(['daemon-reload'], { dryRun });
-  runSystemctl(['enable', '--now', serviceName], { dryRun });
+  try {
+    runSystemctl(['daemon-reload'], { dryRun });
+    runSystemctl(['enable', '--now', serviceName], { dryRun });
+    info(`service started with systemd --user: ${serviceName}`);
+    return;
+  } catch (err) {
+    const detail = String(err?.message || err);
+    info(`systemd --user unavailable, fallback to detached process (${detail})`);
+    printSystemdFallbackHints(detail);
+  }
+
+  const started = startDetachedProxyProcess({ nodeBin, cliPath, serveArgs, dryRun });
+  if (!started) {
+    throw new Error(`failed to start proxy with both systemd --user and detached mode`);
+  }
+  info('proxy started in detached mode (non-systemd fallback)');
 }
 
 function runLaunchctl(args, { dryRun, allowFailure = false } = {}) {
@@ -444,7 +507,14 @@ function installService({
   dryRun
 }) {
   if (process.platform === 'linux') {
-    installLinuxService({ serviceName, content: linuxServiceContent, dryRun });
+    installLinuxService({
+      serviceName,
+      content: linuxServiceContent,
+      nodeBin,
+      cliPath,
+      serveArgs,
+      dryRun
+    });
     return;
   }
   if (process.platform === 'darwin') {

package/lib/proxy-server.mjs

@@ -1,6 +1,7 @@
 import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 
 const DEFAULT_PORT = 18888;
 const DEFAULT_UPSTREAM = 'https://sub2api.atools.live';
@@ -10,6 +11,9 @@ const DEFAULT_MAX_REQ_BYTES = 68000;
 const DEFAULT_DROP_TOOLS_ON_COMPACT = false;
 const DEFAULT_STRIP_PREVIOUS_RESPONSE_ID = false;
 const DEFAULT_FORCE_MODEL = '';
+const DEFAULT_DEBUG_DUMP = false;
+const DEFAULT_DEBUG_MAX_BODY = 800000;
+const DEFAULT_DEBUG_INCLUDE_AUTH = false;
 const SUPPORTED_MODEL_IDS = new Set(['gpt-5.2', 'gpt-5.3-codex', 'gpt-5.4']);
 const FORWARD_HEADER_ALLOWLIST = new Set([
   'authorization',
@@ -111,6 +115,15 @@ function normalizeResponsesPayload(payload, {
     });
   }
 
+  const hasFunctionCallOutput = extractFunctionCallOutputIds(out).length > 0;
+  if ((Array.isArray(out.tools) && out.tools.length > 0) || hasFunctionCallOutput) {
+    out.store = true;
+  }
+
+  if (Array.isArray(out.tools) && out.tools.length > 0 && (out.tool_choice == null || out.tool_choice === '')) {
+    out.tool_choice = 'auto';
+  }
+
   return pruneResponsesPayload(out);
 }
 
@@ -200,6 +213,236 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function parseBool(value, fallback = false) {
+  if (typeof value === 'boolean') return value;
+  if (value == null) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return fallback;
+  return ['1', 'true', 'yes', 'on'].includes(normalized);
+}
+
+function maskSecret(value) {
+  const text = String(value ?? '');
+  if (text.length <= 10) return '***';
+  return `${text.slice(0, 6)}...${text.slice(-4)}`;
+}
+
+function toHeaderObject(headers, { includeAuth = DEFAULT_DEBUG_INCLUDE_AUTH } = {}) {
+  const out = {};
+  if (!headers) return out;
+
+  if (typeof headers.forEach === 'function') {
+    headers.forEach((value, key) => {
+      const low = String(key || '').toLowerCase();
+      if (!includeAuth && (low === 'authorization' || low === 'api-key' || low === 'x-api-key')) {
+        out[key] = maskSecret(value);
+      } else {
+        out[key] = String(value);
+      }
+    });
+    return out;
+  }
+
+  for (const [key, rawValue] of Object.entries(headers)) {
+    const value = normalizeHeaderValue(rawValue);
+    const low = String(key || '').toLowerCase();
+    if (!includeAuth && (low === 'authorization' || low === 'api-key' || low === 'x-api-key')) {
+      out[key] = maskSecret(value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+function bufferToDebugText(buf, maxChars = DEFAULT_DEBUG_MAX_BODY) {
+  const text = Buffer.isBuffer(buf) ? buf.toString('utf8') : String(buf ?? '');
+  if (!Number.isFinite(maxChars) || maxChars <= 0) return text;
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n...[truncated ${text.length - maxChars} chars]`;
+}
+
+function hashKey(text) {
+  return crypto.createHash('sha1').update(String(text)).digest('hex').slice(0, 16);
+}
+
+function extractAuthIdentity(headers = {}) {
+  const auth = normalizeHeaderValue(headers.authorization || headers.Authorization || '');
+  if (auth) return auth;
+  const apiKey = normalizeHeaderValue(headers['x-api-key'] || headers['api-key'] || '');
+  return apiKey;
+}
+
+function buildConversationKey(headers = {}, payload = {}) {
+  const authIdentity = extractAuthIdentity(headers);
+  if (!authIdentity) return '';
+  const modelRaw = typeof payload?.model === 'string' ? payload.model : '*';
+  const model = normalizeModelId(modelRaw) || '*';
+  return hashKey(`${authIdentity}|${model}`);
+}
+
+function buildPromptContextKey(headers = {}, payload = {}) {
+  const authIdentity = extractAuthIdentity(headers);
+  if (!authIdentity) return '';
+  const promptCacheKey = typeof payload?.prompt_cache_key === 'string'
+    ? payload.prompt_cache_key.trim()
+    : '';
+  if (!promptCacheKey) return '';
+  const modelRaw = typeof payload?.model === 'string' ? payload.model : '*';
+  const model = normalizeModelId(modelRaw) || '*';
+  return hashKey(`${authIdentity}|${model}|${promptCacheKey}`);
+}
+
+function extractFunctionCallOutputIds(payload = {}) {
+  const ids = [];
+  const input = Array.isArray(payload.input) ? payload.input : [];
+  for (const item of input) {
+    if (!item || typeof item !== 'object') continue;
+
+    if (item.type === 'function_call_output' && typeof item.call_id === 'string' && item.call_id) {
+      ids.push(item.call_id);
+      continue;
+    }
+
+    if (Array.isArray(item.content)) {
+      for (const part of item.content) {
+        if (!part || typeof part !== 'object') continue;
+        if (part.type === 'function_call_output' && typeof part.call_id === 'string' && part.call_id) {
+          ids.push(part.call_id);
+        }
+      }
+    }
+  }
+  return ids;
+}
+
+function extractItemReferenceIds(payload = {}) {
+  const ids = [];
+  const input = Array.isArray(payload.input) ? payload.input : [];
+  for (const item of input) {
+    if (!item || typeof item !== 'object') continue;
+    if (item.type === 'item_reference' && typeof item.id === 'string' && item.id) {
+      ids.push(item.id);
+    }
+  }
+  return ids;
+}
+
+function extractResponseId(contentType, buffer) {
+  const body = bufferToDebugText(buffer, 3_000_000);
+  const ct = String(contentType || '').toLowerCase();
+
+  if (ct.includes('application/json')) {
+    try {
+      const parsed = JSON.parse(body);
+      if (parsed && typeof parsed.id === 'string' && parsed.id) return parsed.id;
+      if (parsed?.response && typeof parsed.response.id === 'string' && parsed.response.id) return parsed.response.id;
+    } catch {
+      return '';
+    }
+    return '';
+  }
+
+  if (ct.includes('text/event-stream')) {
+    const chunks = body.split('\n\n');
+    for (const chunk of chunks) {
+      const dataLines = chunk.split('\n').filter((line) => line.startsWith('data: '));
+      if (!dataLines.length) continue;
+      const dataText = dataLines.map((line) => line.slice(6)).join('\n');
+      if (!dataText || dataText === '[DONE]') continue;
+      try {
+        const parsed = JSON.parse(dataText);
+        if (parsed?.type === 'response.created' && typeof parsed?.response?.id === 'string') {
+          return parsed.response.id;
+        }
+        if (parsed?.type === 'response.completed' && typeof parsed?.response?.id === 'string') {
+          return parsed.response.id;
+        }
+      } catch {
+        // ignore malformed SSE chunk
+      }
+    }
+  }
+
+  return '';
+}
+
+function setCachedResponseId(cache, key, responseId) {
+  if (!key || !responseId) return;
+  cache.set(key, responseId);
+  if (cache.size > 300) {
+    const first = cache.keys().next();
+    if (!first.done) cache.delete(first.value);
+  }
+}
+
+function setCachedCallIdContext(cache, callId, responseId) {
+  if (!callId || !responseId) return;
+  cache.set(callId, responseId);
+  if (cache.size > 1200) {
+    const first = cache.keys().next();
+    if (!first.done) cache.delete(first.value);
+  }
+}
+
+function extractFunctionCallIdsFromResponse(contentType, buffer) {
+  const ids = [];
+  const body = bufferToDebugText(buffer, 3_000_000);
+  const ct = String(contentType || '').toLowerCase();
+
+  if (ct.includes('application/json')) {
+    try {
+      const parsed = JSON.parse(body);
+      const output = Array.isArray(parsed?.output) ? parsed.output : [];
+      for (const item of output) {
+        if (item?.type === 'function_call' && typeof item.call_id === 'string' && item.call_id) {
+          ids.push(item.call_id);
+        }
+      }
+    } catch {
+      return ids;
+    }
+    return ids;
+  }
+
+  if (ct.includes('text/event-stream')) {
+    const chunks = body.split('\n\n');
+    for (const chunk of chunks) {
+      const dataLines = chunk.split('\n').filter((line) => line.startsWith('data: '));
+      if (!dataLines.length) continue;
+      const dataText = dataLines.map((line) => line.slice(6)).join('\n');
+      if (!dataText || dataText === '[DONE]') continue;
+      try {
+        const parsed = JSON.parse(dataText);
+        if (parsed?.type === 'response.output_item.added') {
+          const item = parsed?.item;
+          if (item?.type === 'function_call' && typeof item.call_id === 'string' && item.call_id) {
+            ids.push(item.call_id);
+          }
+        }
+      } catch {
+        // ignore malformed SSE chunk
+      }
+    }
+  }
+
+  return ids;
+}
+
+function parseSseEventDataText(eventBlock = '') {
+  const dataLines = String(eventBlock)
+    .split('\n')
+    .filter((line) => line.startsWith('data: '));
+  if (!dataLines.length) return null;
+  const dataText = dataLines.map((line) => line.slice(6)).join('\n');
+  if (!dataText || dataText === '[DONE]') return null;
+  try {
+    return JSON.parse(dataText);
+  } catch {
+    return null;
+  }
+}
+
 async function forward(url, req, headers, body) {
   return fetch(url, {
     method: req.method,
@@ -252,6 +495,15 @@ export async function createProxyServer(options = {}) {
   const stripPreviousResponseId = options.stripPreviousResponseId
     ?? ['1', 'true', 'yes', 'on'].includes(String(process.env.SUB2API_COMPAT_STRIP_PREVIOUS_RESPONSE_ID || '').toLowerCase());
   const forceModel = String(options.forceModel ?? process.env.SUB2API_COMPAT_FORCE_MODEL ?? '').trim();
+  const debugDump = parseBool(options.debugDump ?? process.env.SUB2API_COMPAT_DEBUG_DUMP, DEFAULT_DEBUG_DUMP);
+  const debugMaxBody = Number(options.debugMaxBody ?? process.env.SUB2API_COMPAT_DEBUG_MAX_BODY ?? DEFAULT_DEBUG_MAX_BODY);
+  const debugIncludeAuth = parseBool(
+    options.debugIncludeAuth ?? process.env.SUB2API_COMPAT_DEBUG_INCLUDE_AUTH,
+    DEFAULT_DEBUG_INCLUDE_AUTH
+  );
+  const responseContextCache = new Map();
+  const promptContextCache = new Map();
+  const callIdContextCache = new Map();
 
   const server = http.createServer(async (req, res) => {
     const startAt = Date.now();
@@ -262,21 +514,83 @@ export async function createProxyServer(options = {}) {
       const rawBody = Buffer.concat(chunks);
 
       const baseHeaders = buildCodexLikeHeaders(req.headers, userAgent);
+      const incomingHeaders = toHeaderObject(req.headers, { includeAuth: debugIncludeAuth });
 
       const isResponsesPath = req.method === 'POST' && url.pathname.endsWith('/responses');
       let body = rawBody;
       let compactBody = null;
       let aggressiveBody = null;
       let minimalBody = null;
+      let requestedStream = false;
+      let rawBodyText = '';
+      let normalizedBodyText = '';
+      let conversationKey = '';
+      let promptContextKey = '';
+      let functionCallOutputIds = [];
 
       if (isResponsesPath && rawBody.length > 0) {
         try {
           const parsed = JSON.parse(rawBody.toString('utf8'));
+          rawBodyText = JSON.stringify(parsed);
           const inputModel = typeof parsed.model === 'string' ? parsed.model : '';
           const normalized = normalizeResponsesPayload(parsed, {
             stripPreviousResponseId,
             forceModel
           });
+          requestedStream = normalized?.stream === true;
+          conversationKey = buildConversationKey(req.headers, normalized);
+          promptContextKey = buildPromptContextKey(req.headers, normalized);
+          functionCallOutputIds = extractFunctionCallOutputIds(normalized);
+          if (functionCallOutputIds.length > 0 && !normalized.previous_response_id) {
+            let cachedResponseId = '';
+            let source = '';
+            const matched = new Set();
+            for (const callId of functionCallOutputIds) {
+              const responseId = callIdContextCache.get(callId);
+              if (responseId) matched.add(responseId);
+            }
+            if (matched.size === 1) {
+              cachedResponseId = [...matched][0];
+              source = 'call_id';
+            } else if (promptContextKey) {
+              cachedResponseId = promptContextCache.get(promptContextKey) || '';
+              if (cachedResponseId) source = 'prompt_cache_key';
+            }
+            if (!cachedResponseId && conversationKey) {
+              cachedResponseId = responseContextCache.get(conversationKey) || '';
+              if (cachedResponseId) source = 'conversation';
+            }
+            if (cachedResponseId) {
+              normalized.previous_response_id = cachedResponseId;
+              normalized.store = true;
+              appendLog(logFile, {
+                method: req.method,
+                path: url.pathname,
+                contextRepair: {
+                  source,
+                  previous_response_id: cachedResponseId,
+                  function_call_output_count: functionCallOutputIds.length
+                }
+              });
+            }
+            if (!cachedResponseId && Array.isArray(normalized.input)) {
+              const existingRefs = new Set(extractItemReferenceIds(normalized));
+              const missingCallIds = [...new Set(functionCallOutputIds)].filter((id) => !existingRefs.has(id));
+              if (missingCallIds.length > 0) {
+                const refs = missingCallIds.map((id) => ({ type: 'item_reference', id }));
+                normalized.input = [...refs, ...normalized.input];
+                appendLog(logFile, {
+                  method: req.method,
+                  path: url.pathname,
+                  contextRepair: {
+                    item_reference_injected: missingCallIds.length
+                  }
+                });
+              }
+            }
+          }
+          requestedStream = normalized?.stream === true;
+          normalizedBodyText = JSON.stringify(normalized);
           const outputModel = typeof normalized.model === 'string' ? normalized.model : '';
           body = Buffer.from(JSON.stringify(normalized));
           if (body.length > maxReqBytes) {
@@ -310,8 +624,11 @@ export async function createProxyServer(options = {}) {
             });
           }
         } catch {
+          rawBodyText = bufferToDebugText(rawBody, debugMaxBody);
           // Keep original body if parse fails.
         }
+      } else if (rawBody.length > 0) {
+        rawBodyText = bufferToDebugText(rawBody, debugMaxBody);
       }
 
       const requestBodies = [body];
@@ -330,11 +647,17 @@ export async function createProxyServer(options = {}) {
         requestBodies.push(minimalBody);
       }
 
-      let resp;
       let attempts = 0;
       let primaryStatus = null;
       let compacted = false;
       let strategy = 'full';
+      let finalStatus = 502;
+      let finalHeaders = {};
+      let outBuffer = Buffer.alloc(0);
+      let streamResp = null;
+      let streamObservedResponseId = '';
+      const streamObservedCallIds = new Set();
+      const debugAttempts = [];
       const maxAttempts = isResponsesPath ? retryMax : 1;
       while (attempts < maxAttempts) {
         attempts += 1;
@@ -347,8 +670,42 @@ export async function createProxyServer(options = {}) {
         const primaryHeaders = isResponsesPath ? buildHeaders(baseHeaders, requestBody.length) : baseHeaders;
 
         const primaryResp = await forward(url, req, primaryHeaders, requestBody);
+        const attemptHeaders = toHeaderObject(primaryResp.headers, { includeAuth: debugIncludeAuth });
         primaryStatus = primaryResp.status;
-        resp = primaryResp;
+        finalStatus = primaryResp.status;
+        finalHeaders = attemptHeaders;
+
+        if (requestedStream && primaryResp.status < 500) {
+          streamResp = primaryResp;
+          if (debugDump) {
+            debugAttempts.push({
+              attempt: attempts,
+              strategy,
+              requestHeaders: toHeaderObject(primaryHeaders, { includeAuth: debugIncludeAuth }),
+              requestBody: bufferToDebugText(requestBody, debugMaxBody),
+              responseStatus: primaryResp.status,
+              responseHeaders: attemptHeaders,
+              responseBody: '[stream passthrough]'
+            });
+          }
+          break;
+        }
+
+        const attemptBuffer = Buffer.from(await primaryResp.arrayBuffer());
+        outBuffer = attemptBuffer;
+
+        if (debugDump) {
+          debugAttempts.push({
+            attempt: attempts,
+            strategy,
+            requestHeaders: toHeaderObject(primaryHeaders, { includeAuth: debugIncludeAuth }),
+            requestBody: bufferToDebugText(requestBody, debugMaxBody),
+            responseStatus: primaryResp.status,
+            responseHeaders: attemptHeaders,
+            responseBody: bufferToDebugText(attemptBuffer, debugMaxBody)
+          });
+        }
+
         if (primaryResp.status < 500) break;
 
         if (attempts < maxAttempts) {
@@ -356,20 +713,91 @@ export async function createProxyServer(options = {}) {
         }
       }
 
-      res.statusCode = resp.status;
-      resp.headers.forEach((value, key) => {
+      res.statusCode = finalStatus;
+      Object.entries(finalHeaders).forEach(([key, value]) => {
         if (key.toLowerCase() === 'transfer-encoding') return;
         res.setHeader(key, value);
       });
 
-      const outBuffer = Buffer.from(await resp.arrayBuffer());
-      const upstreamError = resp.status >= 500
+      if (streamResp?.body) {
+        const streamed = [];
+        let sseCarry = '';
+        for await (const chunk of streamResp.body) {
+          const buf = Buffer.from(chunk);
+          streamed.push(buf);
+          if (isResponsesPath) {
+            sseCarry += buf.toString('utf8').replace(/\r\n/g, '\n');
+            let splitIndex = sseCarry.indexOf('\n\n');
+            while (splitIndex >= 0) {
+              const eventBlock = sseCarry.slice(0, splitIndex);
+              sseCarry = sseCarry.slice(splitIndex + 2);
+              const parsedEvent = parseSseEventDataText(eventBlock);
+              if (parsedEvent) {
+                const eventResponseId = typeof parsedEvent?.response?.id === 'string'
+                  ? parsedEvent.response.id
+                  : '';
+                if (!streamObservedResponseId && eventResponseId) {
+                  streamObservedResponseId = eventResponseId;
+                  setCachedResponseId(responseContextCache, conversationKey, streamObservedResponseId);
+                  setCachedResponseId(promptContextCache, promptContextKey, streamObservedResponseId);
+                }
+                if (
+                  parsedEvent?.type === 'response.output_item.added'
+                  || parsedEvent?.type === 'response.output_item.done'
+                ) {
+                  const item = parsedEvent?.item;
+                  const callId = (item?.type === 'function_call' && typeof item?.call_id === 'string')
+                    ? item.call_id
+                    : '';
+                  if (callId) {
+                    streamObservedCallIds.add(callId);
+                    if (streamObservedResponseId) {
+                      setCachedCallIdContext(callIdContextCache, callId, streamObservedResponseId);
+                    }
+                  }
+                }
+              }
+              splitIndex = sseCarry.indexOf('\n\n');
+            }
+          }
+          res.write(buf);
+        }
+        outBuffer = Buffer.concat(streamed);
+        res.end();
+      } else {
+        res.end(outBuffer);
+      }
+
+      const upstreamError = finalStatus >= 500
         ? outBuffer.toString('utf8').replace(/\s+/g, ' ').slice(0, 240)
         : '';
+      const finalContentType = finalHeaders['content-type'] || '';
+      const responseId = streamObservedResponseId || extractResponseId(finalContentType, outBuffer);
+      if (responseId) {
+        setCachedResponseId(responseContextCache, conversationKey, responseId);
+        setCachedResponseId(promptContextCache, promptContextKey, responseId);
+        const callIds = extractFunctionCallIdsFromResponse(finalContentType, outBuffer);
+        for (const callId of streamObservedCallIds) {
+          setCachedCallIdContext(callIdContextCache, callId, responseId);
+        }
+        for (const callId of callIds) {
+          setCachedCallIdContext(callIdContextCache, callId, responseId);
+        }
+        if (callIds.length > 0 || streamObservedCallIds.size > 0) {
+          appendLog(logFile, {
+            method: req.method,
+            path: url.pathname,
+            contextCacheUpdate: {
+              response_id: responseId,
+              call_ids: Math.max(callIds.length, streamObservedCallIds.size)
+            }
+          });
+        }
+      }
       appendLog(logFile, {
         method: req.method,
         path: url.pathname,
-        status: resp.status,
+        status: finalStatus,
         attempts,
         primaryStatus,
         compacted,
@@ -380,7 +808,24 @@ export async function createProxyServer(options = {}) {
         ...(upstreamError ? { upstreamError } : {}),
         durationMs: Date.now() - startAt
       });
-      res.end(outBuffer);
+      if (debugDump) {
+        appendLog(logFile, {
+          kind: 'debug_dump',
+          method: req.method,
+          path: url.pathname,
+          upstream: url.toString(),
+          incomingHeaders,
+          normalizedHeaders: toHeaderObject(baseHeaders, { includeAuth: debugIncludeAuth }),
+          rawRequestBody: bufferToDebugText(rawBodyText || rawBody, debugMaxBody),
+          normalizedRequestBody: bufferToDebugText(normalizedBodyText || body, debugMaxBody),
+          attempts: debugAttempts,
+          finalResponse: {
+            status: finalStatus,
+            headers: finalHeaders,
+            body: bufferToDebugText(outBuffer, debugMaxBody)
+          }
+        });
+      }
     } catch (err) {
       const message = String(err?.message || err);
       appendLog(logFile, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autotask/atools-tool",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "ATools CLI for OpenClaw proxy compatibility and interactive model configuration",
   "type": "module",
   "license": "MIT",