@bash0816/copilot-termux 1.0.63

package/THIRD-PARTY-LICENSES/NODE-PTY-LICENSE.txt

@@ -0,0 +1,69 @@
+Copyright (c) 2012-2015, Christopher Jeffrey (https://github.com/chjj/)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+
+The MIT License (MIT)
+
+Copyright (c) 2016, Daniel Imms (http://www.growingwiththeweb.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+MIT License
+
+Copyright (c) 2018 - present Microsoft Corporation
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,66 @@
+# Third-Party Notices
+
+This package includes third-party software with the following licenses.
+
+---
+
+## GitHub Copilot CLI
+
+- Source: https://github.com/github/copilot-cli (private)
+- Version: 1.0.63
+- License: GitHub Copilot CLI License
+- License text: THIRD-PARTY-LICENSES/COPILOT-LICENSE.md
+
+Redistributed in unmodified form as part of this package, in accordance with
+Section 2 of the GitHub Copilot CLI License.
+
+Files: lib/copilot/
+
+---
+
+## Node.js
+
+- Source: https://nodejs.org/
+- License: MIT (main), with bundled components under various licenses
+  (see THIRD-PARTY-LICENSES/NODE-LICENSE.txt for full attribution)
+- License text: THIRD-PARTY-LICENSES/NODE-LICENSE.txt
+
+Files: lib/node
+
+---
+
+## GNU C Library (glibc)
+
+- Source: https://www.gnu.org/software/libc/
+- License: LGPL-2.1+
+- License text: THIRD-PARTY-LICENSES/LGPL-2.1.txt
+
+Files:
+  lib/glibc/ld-linux-aarch64.so.1
+  lib/glibc/libc.so.6
+  lib/glibc/libm.so.6
+
+---
+
+## GCC Runtime Libraries
+
+- Source: https://gcc.gnu.org/
+- License: GPL-3.0 WITH GCC Runtime Library Exception
+- Exception text: THIRD-PARTY-LICENSES/GCC-RUNTIME-EXCEPTION.txt
+- Base license text: THIRD-PARTY-LICENSES/GPL-3.0.txt
+
+Files:
+  lib/glibc/libgcc_s.so.1
+  lib/glibc/libstdc++.so.6
+
+---
+
+## node-pty
+
+- Source: https://github.com/microsoft/node-pty
+- Version: 1.1.0
+- License: MIT
+- License text: THIRD-PARTY-LICENSES/NODE-PTY-LICENSE.txt
+
+Compiled natively for Android aarch64 (bionic) and bundled as `lib/native/pty.node`.
+Used to provide pseudo-terminal support for the interactive TUI mode of @github/copilot.

package/bin/copilot

@@ -0,0 +1,70 @@
+#!/bin/sh
+set -eu
+SELF="$0"
+while [ -L "${SELF}" ]; do
+  DIR=$(CDPATH= cd -- "$(dirname -- "${SELF}")" && pwd)
+  SELF="$(readlink "${SELF}")"
+  case "${SELF}" in /*) ;; *) SELF="${DIR}/${SELF}" ;; esac
+done
+PACKAGE_DIR=$(CDPATH= cd -- "$(dirname -- "${SELF}")/.." && pwd)
+_COMPAT="${PACKAGE_DIR}/lib/bionic-compat.so"
+[ -f "${_COMPAT}" ] || { echo '[copilot-termux] ERROR: lib/bionic-compat.so missing. Reinstall package.' >&2; exit 1; }
+PRELOAD="${_COMPAT}${LD_PRELOAD:+:${LD_PRELOAD}}"
+
+CACHE_DIR="${HOME}/.copilot-termux"
+CURRENT="${CACHE_DIR}/current"
+
+if [ ! -d "${CURRENT}" ]; then
+  echo "[copilot-termux] Not set up. Run: copilot-termux setup" >&2
+  exit 1
+fi
+
+COPILOT_INDEX="${CURRENT}/index.js"
+if [ ! -f "${COPILOT_INDEX}" ]; then
+  echo "[copilot-termux] Installation broken. Run: copilot-termux setup" >&2
+  exit 1
+fi
+
+MXC_WRAP="${CACHE_DIR}/mxc-wrap"
+if [ -d "${MXC_WRAP}/arm64" ] && [ -x "${MXC_WRAP}/arm64/lxc-exec" ]; then
+  export MXC_BIN_DIR="${MXC_WRAP}"
+fi
+
+if [ -n "${MAGI_NODE:-}" ]; then
+  MAGI_NODE_VERSION="$("${MAGI_NODE}" --version 2>/dev/null || true)"
+  MAGI_NODE_MAJOR=""
+  if [ -n "${MAGI_NODE_VERSION}" ]; then
+    MAGI_NODE_VERSION="${MAGI_NODE_VERSION#v}"
+    MAGI_NODE_MAJOR="${MAGI_NODE_VERSION%%.*}"
+  fi
+
+  case "${MAGI_NODE_MAJOR}" in
+    ''|*[!0-9]*)
+      echo "[copilot-termux] MAGI_NODE version check failed; falling back to node" >&2
+      LD_PRELOAD="${PRELOAD}" exec node \
+        --require "${PACKAGE_DIR}/lib/platform-patch.js" \
+        "${COPILOT_INDEX}" \
+        "$@"
+      ;;
+  esac
+
+  if [ "${MAGI_NODE_MAJOR}" -lt 24 ]; then
+    echo "[copilot-termux] MAGI_NODE ${MAGI_NODE_VERSION} is below v24; falling back to node" >&2
+    LD_PRELOAD="${PRELOAD}" exec node \
+      --require "${PACKAGE_DIR}/lib/platform-patch.js" \
+      "${COPILOT_INDEX}" \
+      "$@"
+  fi
+
+  exec env -u LD_LIBRARY_PATH \
+    LD_PRELOAD="${PRELOAD}" \
+    "${MAGI_NODE}" \
+    --require "${PACKAGE_DIR}/lib/platform-patch.js" \
+    "${COPILOT_INDEX}" \
+    "$@"
+fi
+
+LD_PRELOAD="${PRELOAD}" exec node \
+  --require "${PACKAGE_DIR}/lib/platform-patch.js" \
+  "${COPILOT_INDEX}" \
+  "$@"

package/bin/copilot-termux

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+'use strict';
+const { setup } = require('../lib/setup');
+const cmd = process.argv[2];
+if (cmd === 'setup' || cmd === 'update') {
+  setup().then(() => process.exit(0)).catch(e => { console.error(e.message); process.exit(1); });
+} else {
+  console.log('Usage: copilot-termux <setup|update>');
+}

package/config/manifest.json

@@ -0,0 +1,7 @@
+{
+  "wrapperVersion": "2.0.0",
+  "copilot": {
+    "version": "1.0.63",
+    "integrity": "sha512-e8DRYiWJQc4kepVXsXjC8vpDU2FXS/TfR+Z6p/KAojfcwIUZzKMAfCV5D1lD25hV4CryVH1Z9t7mHqChickj0Q=="
+  }
+}

package/lib/platform-patch.js

@@ -0,0 +1,451 @@
+'use strict';
+// Override process.platform so @github/copilot treats Android as Linux.
+// @github/copilot is distributed unmodified (LICENSE Section 2).
+// This file is our code and is NOT part of the @github/copilot software.
+Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+
+if (process.report) {
+  const orig = process.report.getReport.bind(process.report);
+  process.report.getReport = (...args) => {
+    const r = orig(...args);
+    if (r && r.header) r.header.platform = 'linux';
+    return r;
+  };
+}
+
+// Redirect linux-arm64 native addons to bionic-compatible variants.
+// bionic Node.js cannot load glibc addons; glibc fallback causes segfault.
+const Module = require('module');
+const fs = require('fs');
+const path = require('path');
+
+// Bundled Termux-native pty.node (built against bionic, not glibc).
+const NATIVE_PTY = path.join(__dirname, 'native', 'pty.node');
+
+const origResolve = Module._resolveFilename.bind(Module);
+Module._resolveFilename = function (request, parent, isMain, options) {
+  if (typeof request === 'string' && request.endsWith('.node')) {
+    // Redirect pty.node to our bundled Termux-native build.
+    if (path.basename(request) === 'pty.node' &&
+        (request.includes('linux-arm64') || request.includes('linuxmusl-arm64'))) {
+      if (fs.existsSync(NATIVE_PTY)) return NATIVE_PTY;
+    }
+
+    // Redirect other linux-arm64 addons to linuxmusl-arm64 variants.
+    if (request.includes('linux-arm64')) {
+      const muslReq = request.replace(/linux-arm64/g, 'linuxmusl-arm64');
+      try {
+        const resolved = origResolve(muslReq, parent, isMain, options);
+        if (fs.existsSync(resolved)) return resolved;
+      } catch (e) {
+        if (e.code !== 'MODULE_NOT_FOUND') throw e;
+      }
+      // Block glibc fallback — loading linux-arm64 (glibc) on bionic causes segfault.
+      throw new Error(
+        `[copilot-termux] Cannot load glibc addon on bionic: ${request}\n` +
+        'No linuxmusl-arm64 variant available. This addon is not supported on Android.'
+      );
+    }
+  }
+  return origResolve(request, parent, isMain, options);
+};
+
+// [Android bionic 対応] linuxmusl-arm64/runtime.node は Rust tokio を使う。
+// bionic 上で musl pthread ABI でスレッドを生成すると TUI 起動時に SIGSEGV。
+// runtime.node ロード後に Rust async 初期化関数を no-op に差し替えて阻止する。
+const origLoad = Module._load.bind(Module);
+Module._load = function (request, parent, isMain) {
+  const result = origLoad(request, parent, isMain);
+  if (typeof request === 'string' &&
+      path.basename(request) === 'runtime.node') {
+    // Rust tokio を使う関数群を no-op に差し替え。
+    // sessionStore*/sessionSqlite* は非同期 SQLite (tokio)、
+    // modelHttp*/networkFetch*/ahpRelay*/websocketResponses* は Rust HTTP (tokio)。
+    // featureFlagService* は同期 Rust のため除外（no-op にすると .handle クラッシュ）。
+    const TOKIO_PATTERN = /^(modelHttp|networkFetch|ahpRelay|websocketResponses|sessionStore|sessionSqlite)/;
+    for (const key of Object.keys(result)) {
+      if (TOKIO_PATTERN.test(key) && typeof result[key] === 'function') {
+        result[key] = () => undefined;
+      }
+    }
+    if (typeof result.networkFetchGetExtraCaPems === 'function') {
+      result.networkFetchGetExtraCaPems = () => ({ errors: [], pems: [] });
+    }
+    // capiClientListModels を Node.js fetch で実装（Rust tokio SIGSEGV 回避）
+    if (typeof result.capiClientListModels === 'function') {
+      result.capiClientListModels = async function(handle, _includeHidden, _skipCache, _applyModelLimitCaps, _networkingConfigId) {
+        let authHeaders;
+        try {
+          const prepared = result.capiClientPrepareRequestHeaders(handle, '', []);
+          authHeaders = {};
+          for (const {name, value} of prepared.headers) {
+            authHeaders[name] = value;
+          }
+        } catch (e) {
+          throw new Error(JSON.stringify({kind: 'network', message: `prepareHeaders failed: ${e.message}`}));
+        }
+        const baseUrl = 'https://api.githubcopilot.com';
+        let res;
+        try {
+          res = await globalThis.fetch(`${baseUrl}/models`, {method: 'GET', headers: authHeaders});
+        } catch (e) {
+          throw new Error(JSON.stringify({kind: 'network', message: e.message}));
+        }
+        if (!res.ok) {
+          const body = await res.text().catch(() => '');
+          const hdrs = [...res.headers.entries()].map(([name, value]) => ({name, value}));
+          throw new Error(JSON.stringify({kind: 'http', status: res.status, statusText: res.statusText, body, headers: hdrs, hasRequestId: res.headers.has('x-request-id')}));
+        }
+        const data = await res.json();
+        const models = Array.isArray(data) ? data : (data.data ?? data.models ?? []);
+        const rateHeaders = [...res.headers.entries()].map(([name, value]) => ({name, value}));
+        return {modelsJson: JSON.stringify(models), copilotUrl: baseUrl, usageRatelimitHeaders: rateHeaders, capturedAssignmentContext: undefined};
+      };
+    }
+    if (typeof result.sessionSqliteOpen === 'function') {
+      result.sessionSqliteOpen = () => 1;
+    }
+    if (typeof result.sessionSqliteQuery === 'function') {
+      result.sessionSqliteQuery = () => ({ rows: '[]' });
+    }
+    if (typeof result.sessionSqliteRun === 'function') {
+      result.sessionSqliteRun = () => ({ rowsAffected: 0, lastInsertRowid: null });
+    }
+    if (typeof result.sessionSqliteFileExists === 'function') {
+      result.sessionSqliteFileExists = () => false;
+    }
+    // --- JS networkFetch* implementation (bionic: tokio networkFetch* are no-op'd) ---
+    // B7 が QXe() から直接呼ばれる MCP 専用パスでクラッシュするため JS で代替。
+    // networkFetchStreamStart → { requestId, response: Promise<{handle,url,status,statusText,headers}> }
+    // networkFetchStreamRead   → Promise<{ done, body?: Uint8Array }>
+    // networkFetchStreamClose  → void
+    // networkFetchRequestCancel → void
+    const _nfMap = new Map();
+    let _nfIdSeq = 3e6;
+
+    result.networkFetchStreamStart = function(req) {
+      const requestId = 'nf-' + (++_nfIdSeq);
+      const abortCtrl = new AbortController();
+      const entry = { abort: () => abortCtrl.abort(), reader: null };
+      _nfMap.set(requestId, entry);
+
+      const headers = {};
+      if (Array.isArray(req.headers)) {
+        for (const { name, value } of req.headers) headers[name] = value;
+      } else if (req.headers && typeof req.headers === 'object') {
+        Object.assign(headers, req.headers);
+      }
+
+      const response = (async () => {
+        let res;
+        try {
+          res = await globalThis.fetch(req.url, {
+            method: req.method || 'GET',
+            headers,
+            body: req.body ?? undefined,
+            signal: abortCtrl.signal,
+            redirect: req.redirect || 'follow',
+          });
+        } catch (e) {
+          _nfMap.delete(requestId);
+          throw e;
+        }
+        const handle = requestId;
+        const reader = res.body ? res.body.getReader() : null;
+        entry.reader = reader;
+        const respHeaders = [...res.headers.entries()].map(([name, value]) => ({ name, value }));
+        return { handle, url: res.url, status: res.status, statusText: res.statusText, headers: respHeaders };
+      })();
+
+      return { requestId, response };
+    };
+
+    result.networkFetchStreamRead = function(handle) {
+      return (async () => {
+        const entry = _nfMap.get(handle);
+        if (!entry || !entry.reader) return { done: true };
+        try {
+          const { done, value } = await entry.reader.read();
+          if (done) { _nfMap.delete(handle); return { done: true }; }
+          return { done: false, body: value };
+        } catch (e) {
+          _nfMap.delete(handle);
+          throw e;
+        }
+      })();
+    };
+
+    result.networkFetchStreamClose = function(handle) {
+      const entry = _nfMap.get(handle);
+      if (entry) {
+        try { entry.reader?.cancel(); } catch (_) {}
+        try { entry.abort(); } catch (_) {}
+        _nfMap.delete(handle);
+      }
+    };
+
+    result.networkFetchRequestCancel = function(requestId) {
+      const entry = _nfMap.get(requestId);
+      if (entry) {
+        try { entry.abort(); } catch (_) {}
+        _nfMap.delete(requestId);
+      }
+    };
+
+    result.networkFetchResetClients = function() {
+      for (const entry of _nfMap.values()) {
+        try { entry.abort(); } catch (_) {}
+      }
+      _nfMap.clear();
+    };
+    // --- end JS networkFetch* implementation ---
+    // --- JS model HTTP implementation (bionic: tokio modelHttp* are no-op'd) ---
+    // Stream store: streamId → {events, index, finalMessage}
+    const _jsStreams = new Map();
+    let _accIdSeq = 1e6;
+    // Accumulator store: accId → {message}
+    const _jsAccs = new Map();
+
+    // Helper: parse Anthropic SSE body into events array
+    function _parseAnthropicSSE(bodyText) {
+      const events = [];
+      const lines = bodyText.split(/\r\n|\r|\n/);
+      let dataLines = [];
+      for (const line of lines) {
+        if (line === '' || line === '\r') {
+          if (dataLines.length > 0) {
+            const dataStr = dataLines.join('\n');
+            dataLines = [];
+            if (dataStr.trim() === '[DONE]') continue;
+            try { events.push(JSON.parse(dataStr)); } catch(_) {}
+          }
+        } else if (line.startsWith('data: ')) {
+          dataLines.push(line.slice(6));
+        } else if (line.startsWith('data:')) {
+          dataLines.push(line.slice(5));
+        }
+      }
+      if (dataLines.length > 0) {
+        const dataStr = dataLines.join('\n');
+        if (dataStr.trim() !== '[DONE]') {
+          try { events.push(JSON.parse(dataStr)); } catch(_) {}
+        }
+      }
+      return events;
+    }
+
+    // Helper: reconstruct final Anthropic message from SSE events
+    function _reconstructFinalMessage(events) {
+      let message = null;
+      const contentBlocks = new Map(); // index → block
+      for (const e of events) {
+        if (e.type === 'message_start') {
+          message = {
+            id: e.message && e.message.id,
+            type: (e.message && e.message.type) || 'message',
+            role: (e.message && e.message.role) || 'assistant',
+            model: e.message && e.message.model,
+            stop_reason: (e.message && e.message.stop_reason) || null,
+            stop_sequence: (e.message && e.message.stop_sequence) || null,
+            usage: (e.message && e.message.usage) || { input_tokens: 0, output_tokens: 0 },
+            content: []
+          };
+        } else if (e.type === 'content_block_start') {
+          const blk = e.content_block;
+          if (!blk) continue;
+          if (blk.type === 'text') {
+            contentBlocks.set(e.index, { type: 'text', text: blk.text || '' });
+          } else if (blk.type === 'tool_use') {
+            contentBlocks.set(e.index, { type: 'tool_use', id: blk.id, name: blk.name, _inputBuf: '' });
+          } else if (blk.type === 'thinking') {
+            contentBlocks.set(e.index, { type: 'thinking', thinking: blk.thinking || '', signature: blk.signature || '' });
+          } else if (blk.type === 'redacted_thinking') {
+            contentBlocks.set(e.index, { type: 'redacted_thinking', data: blk.data });
+          }
+        } else if (e.type === 'content_block_delta') {
+          const blk = contentBlocks.get(e.index);
+          if (!blk || !e.delta) continue;
+          if (e.delta.type === 'text_delta') {
+            blk.text = (blk.text || '') + (e.delta.text || '');
+          } else if (e.delta.type === 'input_json_delta') {
+            blk._inputBuf = (blk._inputBuf || '') + (e.delta.partial_json || '');
+          } else if (e.delta.type === 'thinking_delta') {
+            blk.thinking = (blk.thinking || '') + (e.delta.thinking || '');
+          } else if (e.delta.type === 'signature_delta') {
+            blk.signature = (blk.signature || '') + (e.delta.signature || '');
+          }
+        } else if (e.type === 'content_block_stop') {
+          const blk = contentBlocks.get(e.index);
+          if (blk && blk.type === 'tool_use') {
+            try { blk.input = JSON.parse(blk._inputBuf || '{}'); } catch(_) { blk.input = {}; }
+            delete blk._inputBuf;
+          }
+        } else if (e.type === 'message_delta') {
+          if (message) {
+            if (e.delta && e.delta.stop_reason != null) message.stop_reason = e.delta.stop_reason;
+            if (e.delta && e.delta.stop_sequence != null) message.stop_sequence = e.delta.stop_sequence;
+            if (e.usage && e.usage.output_tokens != null && message.usage) {
+              message.usage.output_tokens = e.usage.output_tokens;
+            }
+          }
+        }
+      }
+      if (message) {
+        const blocks = Array.from(contentBlocks.entries())
+          .sort(([a], [b]) => a - b)
+          .map(([, v]) => v);
+        message.content = blocks;
+      }
+      if (!message) {
+        message = { role: 'assistant', content: [], stop_reason: 'error', stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 } };
+      }
+      return message;
+    }
+
+    // 1. anthropicMessageStreamAccumulatorCreate → JS mock
+    if (typeof result.anthropicMessageStreamAccumulatorCreate === 'function') {
+      result.anthropicMessageStreamAccumulatorCreate = function(_handleJson) {
+        const id = _accIdSeq++;
+        _jsAccs.set(id, { message: null });
+        return { json: JSON.stringify({ accumulatorId: id }) };
+      };
+    }
+
+    // 2. anthropicMessageStreamAccumulatorFinish → return accumulated message
+    if (typeof result.anthropicMessageStreamAccumulatorFinish === 'function') {
+      result.anthropicMessageStreamAccumulatorFinish = function(id) {
+        const acc = _jsAccs.get(id) || { message: null };
+        _jsAccs.delete(id);
+        return { json: JSON.stringify({ message: acc.message }) };
+      };
+    }
+
+    // 3. anthropicMessageStreamAccumulatorDrop → cleanup
+    if (typeof result.anthropicMessageStreamAccumulatorDrop === 'function') {
+      result.anthropicMessageStreamAccumulatorDrop = function(id) {
+        _jsAccs.delete(id);
+      };
+    }
+
+    // 4. modelHttpStreamStart → fetch full SSE body, parse events
+    result.modelHttpStreamStart = async function(jsonArg) {
+      const req = JSON.parse(jsonArg);
+      let body = req.body;
+      if (body !== null && body !== undefined && typeof body === 'object') {
+        if (body.type === 'Buffer' && Array.isArray(body.data)) {
+          body = Buffer.from(body.data);
+        } else {
+          body = JSON.stringify(body);
+        }
+      }
+      let res;
+      try {
+        res = await globalThis.fetch(req.url, {
+          method: req.method || 'POST',
+          headers: req.headers || {},
+          body: body,
+        });
+      } catch(e) {
+        throw new Error(JSON.stringify({ kind: 'network', message: e.message }));
+      }
+      const headers = {};
+      for (const [k, v] of res.headers.entries()) headers[k] = v;
+      const bodyText = await res.text().catch(() => '');
+      if (res.status < 200 || res.status >= 300) {
+        return { json: JSON.stringify({ bodyText, status: res.status, statusText: res.statusText, headers, streamId: null }) };
+      }
+      const events = _parseAnthropicSSE(bodyText);
+      const finalMessage = _reconstructFinalMessage(events);
+      const streamId = 'js-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+      _jsStreams.set(streamId, { events, index: 0, finalMessage });
+      return { json: JSON.stringify({ bodyText: null, status: res.status, statusText: res.statusText, headers, streamId }) };
+    };
+
+    // 5. modelHttpStreamNextAnthropicMessageEvent → yield events one by one
+    result.modelHttpStreamNextAnthropicMessageEvent = async function(streamId, accId) {
+      const st = _jsStreams.get(streamId);
+      if (!st || st.index >= st.events.length) {
+        if (st) {
+          const acc = _jsAccs.get(accId);
+          if (acc) acc.message = st.finalMessage;
+          _jsStreams.delete(streamId);
+        }
+        return null;
+      }
+      return { json: JSON.stringify({ kind: 'ok', processResult: { event: st.events[st.index++] } }) };
+    };
+
+    // 6. modelHttpStreamCancel → cleanup
+    result.modelHttpStreamCancel = function(streamId) {
+      _jsStreams.delete(streamId);
+    };
+
+    // 7. modelHttpRequest → non-streaming fetch
+    result.modelHttpRequest = async function(jsonArg) {
+      const req = JSON.parse(jsonArg);
+      let body = req.body;
+      if (body !== null && body !== undefined && typeof body === 'object') {
+        if (body.type === 'Buffer' && Array.isArray(body.data)) {
+          body = Buffer.from(body.data);
+        } else {
+          body = JSON.stringify(body);
+        }
+      }
+      let res;
+      try {
+        res = await globalThis.fetch(req.url, {
+          method: req.method || 'POST',
+          headers: req.headers || {},
+          body: body,
+        });
+      } catch(e) {
+        throw new Error(JSON.stringify({ kind: 'network', message: e.message }));
+      }
+      const headers = {};
+      for (const [k, v] of res.headers.entries()) headers[k] = v;
+      const bodyText = await res.text().catch(() => '');
+      return { json: JSON.stringify({ bodyText, status: res.status, statusText: res.statusText, headers }) };
+    };
+    // 8. responsesStreamDrive → JS streamをネイティブリデューサーに流す
+    // native responsesStreamDrive は Rust tokio でストリームを読む。
+    // JS streamId（"js-"で始まる）はRust側にないためクラッシュ → JS実装で代替。
+    const _nativeReducerProcessEvent = typeof result.openaiResponsesStreamReducerProcessEvent === 'function'
+      ? result.openaiResponsesStreamReducerProcessEvent
+      : null;
+    result.responsesStreamDrive = async function(streamId, reducerId, hasProcessors, onChunkCallback) {
+      const st = _jsStreams.get(streamId);
+      if (!st) {
+        throw new Error(`Native mod HTTP stream was not found: ${streamId}`);
+      }
+      _jsStreams.delete(streamId);
+      let copilotUsage = null;
+      for (const event of st.events) {
+        if (!_nativeReducerProcessEvent) continue;
+        let parsed;
+        try { parsed = JSON.parse(_nativeReducerProcessEvent(reducerId, JSON.stringify(event)).json); }
+        catch (_) { continue; }
+        if (parsed && parsed.copilotUsage !== undefined && parsed.copilotUsage !== null)
+          copilotUsage = parsed.copilotUsage;
+        const cc = parsed && parsed.chunkContext;
+        if (hasProcessors && typeof onChunkCallback === 'function' && cc &&
+            (cc.content || cc.messageStart || cc.reportIntentArguments || cc.chunkBoundary || cc.size > 0)) {
+          try { onChunkCallback(JSON.stringify(cc)); } catch (_) {}
+        }
+      }
+      return { json: JSON.stringify({ kind: 'ok', copilotUsage, ttftMs: null, interTokenLatencyMs: null }) };
+    };
+    // --- end JS model HTTP implementation ---
+  }
+  return result;
+};
+
+// [Android bionic 対応] app.js の oPt() が globalThis.fetch を Rust ベースの B7 に
+// 差し替えるのを阻止する。linuxmusl-arm64/runtime.node の Rust ネットワークスタックは
+// bionic 上の実 I/O で動作しないため、Node.js ビルトイン fetch（動作確認済み）に固定する。
+const _nativeFetch = globalThis.fetch;
+Object.defineProperty(globalThis, 'fetch', {
+  configurable: true,
+  enumerable: true,
+  get() { return _nativeFetch; },
+  set(_) { /* B7 代入を無視 */ },
+});