@dcrays/dcgchat-test 0.6.12 → 0.6.13

package/src/utils/streamMerge.ts

@@ -1,150 +0,0 @@
-import type { IMsgParams } from '../types.js'
-import { sendChunk } from '../transport.js'
-import { getWsConnection } from './global.js'
-import { isSessionStreamSuppressed } from './sessionTermination.js'
-import { getInboundGeneration, takeStreamChunkIdxAndAdvance } from './inboundTurnState.js'
-
-export const STREAM_MERGE_PROFILES = [
-  { maxAvgDeltaGapMs: 20, flushIntervalMs: 50, deltaCount: 20, charCount: 100 },
-  { maxAvgDeltaGapMs: 60, flushIntervalMs: 30, deltaCount: 15, charCount: 60 },
-  { maxAvgDeltaGapMs: Number.POSITIVE_INFINITY, flushIntervalMs: 20, deltaCount: 6, charCount: 30 }
-] as const
-
-export const STREAM_MERGE_ENABLE_WINDOW_MS = 1000
-export const STREAM_MERGE_ENABLE_DELTA_COUNT = 50
-export const STREAM_MERGE_IDLE_RESET_MS = 300
-export const STREAM_BACKPRESSURE_HIGH_WATERMARK = 512 * 1024
-export const STREAM_BACKPRESSURE_RETRY_MS = 50
-
-export interface StreamMergeController {
-  queueDelta(delta: string): boolean
-  flush(force?: boolean): boolean
-  dispose(): void
-}
-
-export interface CreateStreamMergeControllerOptions {
-  sessionKey: string
-  inboundGenAtStart: number
-  outboundCtx: IMsgParams
-}
-
-export function createStreamMergeController(
-  options: CreateStreamMergeControllerOptions
-): StreamMergeController {
-  const { sessionKey, inboundGenAtStart, outboundCtx } = options
-
-  let pendingText = ''
-  let pendingDeltaCount = 0
-  let timer: ReturnType<typeof setTimeout> | undefined
-  let mergeMode = false
-  let burstWindowStart = 0
-  let burstDeltaCount = 0
-  let lastDeltaAt = 0
-  let deltaGapAvgMs = 0
-
-  const clearTimer = () => {
-    if (timer) {
-      clearTimeout(timer)
-      timer = undefined
-    }
-  }
-
-  const isBackpressured = () => (getWsConnection()?.bufferedAmount ?? 0) > STREAM_BACKPRESSURE_HIGH_WATERMARK
-
-  const currentProfile = () =>
-    STREAM_MERGE_PROFILES.find((profile) => deltaGapAvgMs <= profile.maxAvgDeltaGapMs) ?? STREAM_MERGE_PROFILES[1]
-
-  const isStale = () =>
-    getInboundGeneration(sessionKey) !== inboundGenAtStart || isSessionStreamSuppressed(sessionKey)
-
-  const emit = (text: string) => sendChunk(text, outboundCtx, takeStreamChunkIdxAndAdvance(sessionKey))
-
-  const resetMerge = () => {
-    mergeMode = false
-    burstWindowStart = 0
-    burstDeltaCount = 0
-    deltaGapAvgMs = 0
-  }
-
-  const flush = (force = false): boolean => {
-    clearTimer()
-    if (!pendingText.trim()) {
-      pendingText = ''
-      pendingDeltaCount = 0
-      return false
-    }
-    if (isStale()) {
-      pendingText = ''
-      pendingDeltaCount = 0
-      return false
-    }
-    if (!force && isBackpressured()) {
-      scheduleFlush(STREAM_BACKPRESSURE_RETRY_MS)
-      return false
-    }
-    const textToSend = pendingText
-    pendingText = ''
-    pendingDeltaCount = 0
-    return emit(textToSend)
-  }
-
-  const scheduleFlush = (delayMs = currentProfile().flushIntervalMs) => {
-    if (timer) return
-    timer = setTimeout(() => flush(), delayMs)
-  }
-
-  const queueDelta = (delta: string): boolean => {
-    const now = Date.now()
-    const deltaGapMs = lastDeltaAt > 0 ? now - lastDeltaAt : 0
-
-    if (lastDeltaAt > 0 && deltaGapMs >= STREAM_MERGE_IDLE_RESET_MS) {
-      flush(true)
-      resetMerge()
-    }
-
-    if (deltaGapMs > 0) {
-      deltaGapAvgMs = deltaGapAvgMs === 0 ? deltaGapMs : deltaGapAvgMs * 0.7 + deltaGapMs * 0.3
-    }
-    lastDeltaAt = now
-
-    if (!mergeMode) {
-      if (burstWindowStart === 0 || now - burstWindowStart > STREAM_MERGE_ENABLE_WINDOW_MS) {
-        burstWindowStart = now
-        burstDeltaCount = 1
-      } else {
-        burstDeltaCount += 1
-      }
-
-      pendingText += delta
-      pendingDeltaCount += 1
-      flush()
-
-      if (burstDeltaCount >= STREAM_MERGE_ENABLE_DELTA_COUNT) {
-        mergeMode = true
-      }
-      return true
-    }
-
-    pendingText += delta
-    pendingDeltaCount += 1
-    const profile = currentProfile()
-    if (pendingText.length >= profile.charCount || pendingDeltaCount >= profile.deltaCount) {
-      flush()
-      return true
-    }
-    scheduleFlush()
-    return true
-  }
-
-  const dispose = () => {
-    clearTimer()
-    pendingText = ''
-    pendingDeltaCount = 0
-  }
-
-  return {
-    queueDelta,
-    flush,
-    dispose
-  }
-}

package/src/utils/subagentRunMap.ts

@@ -1,71 +0,0 @@
-const requesterSessionKeyByRunId = new Map<string, string>()
-const childSessionKeyByRunId = new Map<string, string>()
-
-export type SubagentRunMapSnapshot = {
-  requesterSessionKeyByRunId?: Array<[string, string]>
-  childSessionKeyByRunId?: Array<[string, string]>
-}
-
-export function setSubagentRunRequester(runId: string | undefined, requesterSessionKey: string | undefined): void {
-  const rid = runId?.trim()
-  const req = requesterSessionKey?.trim()
-  if (!rid || !req) return
-  requesterSessionKeyByRunId.set(rid, req)
-}
-
-export function setSubagentRunChild(runId: string | undefined, childSessionKey: string | undefined): void {
-  const rid = runId?.trim()
-  const child = childSessionKey?.trim()
-  if (!rid || !child) return
-  childSessionKeyByRunId.set(rid, child)
-}
-
-export function deleteSubagentRunMappings(runId: string | undefined): void {
-  const rid = runId?.trim()
-  if (!rid) return
-  requesterSessionKeyByRunId.delete(rid)
-  childSessionKeyByRunId.delete(rid)
-}
-
-export function clearSubagentRunMappings(): void {
-  requesterSessionKeyByRunId.clear()
-  childSessionKeyByRunId.clear()
-}
-
-export function resolveRequesterSessionKeyBySubagentRunId(runId: string | undefined): string | undefined {
-  const rid = runId?.trim()
-  if (!rid) return undefined
-  return requesterSessionKeyByRunId.get(rid)
-}
-
-export function resolveChildSessionKeyBySubagentRunId(runId: string | undefined): string | undefined {
-  const rid = runId?.trim()
-  if (!rid) return undefined
-  return childSessionKeyByRunId.get(rid)
-}
-
-export function cleanupSubagentRunMappingsForSessionKeys(sessionKeys: Set<string>): void {
-  for (const [rid, child] of childSessionKeyByRunId.entries()) {
-    if (sessionKeys.has(child)) deleteSubagentRunMappings(rid)
-  }
-  for (const [rid, requester] of requesterSessionKeyByRunId.entries()) {
-    if (sessionKeys.has(requester)) deleteSubagentRunMappings(rid)
-  }
-}
-
-export function snapshotSubagentRunMappings(): SubagentRunMapSnapshot {
-  return {
-    requesterSessionKeyByRunId: [...requesterSessionKeyByRunId.entries()],
-    childSessionKeyByRunId: [...childSessionKeyByRunId.entries()]
-  }
-}
-
-export function restoreSubagentRunMappings(snap: SubagentRunMapSnapshot | null | undefined): void {
-  clearSubagentRunMappings()
-  for (const [k, v] of snap?.requesterSessionKeyByRunId ?? []) {
-    if (typeof k === 'string' && typeof v === 'string' && k && v) requesterSessionKeyByRunId.set(k, v)
-  }
-  for (const [k, v] of snap?.childSessionKeyByRunId ?? []) {
-    if (typeof k === 'string' && typeof v === 'string' && k && v) childSessionKeyByRunId.set(k, v)
-  }
-}

package/src/utils/undiciFetchInterceptor.ts

@@ -1,346 +0,0 @@
-import { realpathSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import path from 'node:path'
-import { dcgLogger } from './log.js'
-
-const UNDICI_WRAPPED_KEY = Symbol.for('dcgchat.undici-fetch-wrapped')
-const GLOBAL_FETCH_WRAPPED_KEY = Symbol.for('dcgchat.global-fetch-wrapped')
-const ORIGINAL_UNDICI_FETCH_KEY = Symbol.for('dcgchat.original-undici-fetch')
-const ORIGINAL_GLOBAL_FETCH_KEY = Symbol.for('dcgchat.original-global-fetch')
-const UNDICI_RUNTIME_DEPS_KEY = '__OPENCLAW_TEST_UNDICI_RUNTIME_DEPS__'
-const PENDING_TTL_MS = 60_000
-const MAX_PENDING_QUEUE = 64
-
-type FetchLike = (input: unknown, init?: unknown) => Promise<Response>
-export type PendingLlmBodyExt = { sessionKey: string }
-
-type PendingEntry = PendingLlmBodyExt & { enqueuedAt: number }
-
-type UndiciLike = {
-  fetch?: FetchLike
-  Agent?: unknown
-  EnvHttpProxyAgent?: unknown
-  ProxyAgent?: unknown
-  FormData?: unknown
-  Headers?: unknown
-  Request?: unknown
-  Response?: unknown
-}
-
-type InterceptorGlobal = typeof globalThis & {
-  [UNDICI_WRAPPED_KEY]?: boolean
-  [GLOBAL_FETCH_WRAPPED_KEY]?: boolean
-  [ORIGINAL_UNDICI_FETCH_KEY]?: FetchLike
-  [ORIGINAL_GLOBAL_FETCH_KEY]?: typeof globalThis.fetch
-  [UNDICI_RUNTIME_DEPS_KEY]?: Record<string, unknown>
-}
-
-const pendingLlmBodyExtQueue: PendingEntry[] = []
-
-function prunePendingQueue(now = Date.now()): void {
-  while (pendingLlmBodyExtQueue.length > 0) {
-    const head = pendingLlmBodyExtQueue[0]
-    if (!head || now - head.enqueuedAt <= PENDING_TTL_MS) break
-    pendingLlmBodyExtQueue.shift()
-  }
-  while (pendingLlmBodyExtQueue.length > MAX_PENDING_QUEUE) {
-    pendingLlmBodyExtQueue.shift()
-  }
-}
-
-function logDroppedPending(dropped: PendingEntry | undefined, reason: string): void {
-  if (dropped) {
-    dcgLogger(`llm body ext pending dropped (${reason}): sessionKey=${dropped.sessionKey}`)
-  }
-}
-
-export function setPendingLlmBodyExt(pending: PendingLlmBodyExt | undefined): void {
-  if (!pending) {
-    pendingLlmBodyExtQueue.length = 0
-    return
-  }
-  const sessionKey = pending.sessionKey.trim()
-  if (!sessionKey) return
-  prunePendingQueue()
-  pendingLlmBodyExtQueue.push({ sessionKey, enqueuedAt: Date.now() })
-}
-
-function getFetchUrl(input: unknown): string {
-  if (typeof input === 'string') return input
-  if (input instanceof URL) return input.toString()
-  if (input && typeof input === 'object' && 'url' in input) {
-    const url = (input as { url?: unknown }).url
-    if (typeof url === 'string') return url
-  }
-  return String(input)
-}
-
-function isLikelyLlmFetch(url: string): boolean {
-  return (
-    url.includes('/chat/completions') ||
-    url.includes('/v1/chat') ||
-    url.includes('/v1/completions') ||
-    (url.includes('/completions') && !url.includes('/embeddings'))
-  )
-}
-
-function looksLikeChatCompletionJsonBody(parsed: unknown): parsed is Record<string, unknown> {
-  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return false
-  const record = parsed as Record<string, unknown>
-  return Array.isArray(record.messages) || typeof record.prompt === 'string'
-}
-
-function isReadableStreamLike(body: unknown): boolean {
-  return Boolean(body && typeof body === 'object' && typeof (body as { getReader?: unknown }).getReader === 'function')
-}
-
-function isNodeStreamLike(body: unknown): boolean {
-  return Boolean(body && typeof body === 'object' && typeof (body as { pipe?: unknown }).pipe === 'function')
-}
-
-function isSafeBodyForTextRead(body: unknown): boolean {
-  if (typeof body === 'string') return true
-  if (typeof Blob !== 'undefined' && body instanceof Blob) return true
-  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return true
-  return false
-}
-
-async function readBodyAsText(body: unknown): Promise<string | null> {
-  if (body == null) return null
-  if (typeof body === 'string') return body
-  if (isReadableStreamLike(body) || isNodeStreamLike(body) || !isSafeBodyForTextRead(body)) return null
-  try {
-    return await new Response(body as BodyInit).text()
-  } catch {
-    return null
-  }
-}
-
-function isRequestLike(input: unknown): input is Request {
-  return Boolean(input && typeof input === 'object' && typeof (input as Request).clone === 'function')
-}
-
-async function resolveRequestBodyText(input: unknown, init?: unknown): Promise<string | null> {
-  const initObj = init && typeof init === 'object' ? (init as RequestInit) : undefined
-  if (initObj?.body != null) {
-    return readBodyAsText(initObj.body)
-  }
-  if (isRequestLike(input)) {
-    try {
-      return await input.clone().text()
-    } catch {
-      return null
-    }
-  }
-  return null
-}
-
-function injectSessionKeyIntoBody(bodyText: string, sessionKey: string): string | null {
-  try {
-    const parsed: unknown = JSON.parse(bodyText)
-    if (!looksLikeChatCompletionJsonBody(parsed)) return null
-
-    const extBase =
-      'ext' in parsed && typeof parsed.ext === 'object' && parsed.ext !== null && !Array.isArray(parsed.ext)
-        ? { ...(parsed.ext as Record<string, unknown>) }
-        : {}
-    parsed.ext = { ...extBase, sessionKey }
-    return JSON.stringify(parsed)
-  } catch {
-    return null
-  }
-}
-
-function headersWithoutContentLength(headers: HeadersInit | undefined): HeadersInit | undefined {
-  if (!headers) return undefined
-  const nextHeaders = new Headers(headers)
-  nextHeaders.delete('content-length')
-  return nextHeaders
-}
-
-function rebuildFetchArgs(input: unknown, init: unknown, body: string): { input: unknown; init?: unknown } {
-  const initObj = init && typeof init === 'object' ? (init as RequestInit) : undefined
-  if (initObj?.body != null) {
-    return { input, init: { ...initObj, headers: headersWithoutContentLength(initObj.headers), body } }
-  }
-  if (isRequestLike(input)) {
-    const nextInit: RequestInit = {
-      method: input.method,
-      headers: headersWithoutContentLength(input.headers),
-      body,
-      redirect: input.redirect,
-      signal: input.signal,
-      credentials: input.credentials,
-      integrity: input.integrity,
-      keepalive: input.keepalive,
-      referrer: input.referrer,
-      referrerPolicy: input.referrerPolicy,
-      mode: input.mode,
-      cache: input.cache
-    }
-    return { input: new Request(input.url, nextInit), init: initObj }
-  }
-  return { input, init: initObj ? { ...initObj, body } : { body } }
-}
-
-async function prepareFetchWithPendingLlmBodyExt(input: unknown, init?: unknown): Promise<{ input: unknown; init?: unknown }> {
-  prunePendingQueue()
-  if (pendingLlmBodyExtQueue.length === 0) return { input, init }
-
-  const url = getFetchUrl(input)
-  if (!isLikelyLlmFetch(url)) return { input, init }
-
-  const pending = pendingLlmBodyExtQueue.shift()
-  if (!pending) return { input, init }
-
-  const bodyText = await resolveRequestBodyText(input, init)
-  if (bodyText == null) {
-    logDroppedPending(pending, 'unreadable body on LLM fetch')
-    return { input, init }
-  }
-
-  const injectedBody = injectSessionKeyIntoBody(bodyText, pending.sessionKey)
-  if (!injectedBody) {
-    logDroppedPending(pending, 'body shape not injectable')
-    return { input, init }
-  }
-
-  dcgLogger(`llm body ext injected: sessionKey=${pending.sessionKey}`)
-  return rebuildFetchArgs(input, init, injectedBody)
-}
-
-function resolveUndici(): UndiciLike | null {
-  const pluginRequire = createRequire(import.meta.url)
-  const candidates: Array<{ label: string; load: () => UndiciLike }> = []
-
-  if (process.argv[1]) {
-    candidates.push({
-      label: 'host-entry',
-      load: () => {
-        const hostEntry = realpathSync(path.resolve(process.argv[1] as string))
-        return createRequire(hostEntry)('undici') as UndiciLike
-      }
-    })
-  }
-
-  candidates.push({
-    label: 'openclaw-package',
-    load: () => {
-      const openclawPackageJson = pluginRequire.resolve('openclaw/package.json')
-      return createRequire(openclawPackageJson)('undici') as UndiciLike
-    }
-  })
-
-  candidates.push({
-    label: 'plugin-local',
-    load: () => pluginRequire('undici') as UndiciLike
-  })
-
-  for (const candidate of candidates) {
-    try {
-      const undici = candidate.load()
-      if (typeof undici?.fetch === 'function') {
-        dcgLogger(`undici resolved via ${candidate.label}`)
-        return undici
-      }
-    } catch {
-      // Try the next resolution root.
-    }
-  }
-  return null
-}
-
-function copyFunctionShape(target: FetchLike, source: FetchLike): void {
-  try {
-    Object.assign(target, source)
-  } catch {
-    // Some runtimes expose non-writable function properties; the wrapper still works without copying them.
-  }
-}
-
-function installGlobalFetchPatch(): boolean {
-  const g = globalThis as InterceptorGlobal
-  if (g[GLOBAL_FETCH_WRAPPED_KEY]) return true
-  if (typeof globalThis.fetch !== 'function') {
-    dcgLogger('global fetch body ext patch skipped: globalThis.fetch unavailable', 'error')
-    return false
-  }
-
-  const originalFetch = globalThis.fetch.bind(globalThis)
-  g[ORIGINAL_GLOBAL_FETCH_KEY] = globalThis.fetch
-
-  const patchedFetch = async function patchedGlobalFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-    const prepared = await prepareFetchWithPendingLlmBodyExt(input, init)
-    return originalFetch(prepared.input as RequestInfo | URL, prepared.init as RequestInit | undefined)
-  }
-  try {
-    Object.assign(patchedFetch, globalThis.fetch)
-  } catch {
-    // The patch only needs call compatibility.
-  }
-
-  globalThis.fetch = patchedFetch as typeof globalThis.fetch
-  g[GLOBAL_FETCH_WRAPPED_KEY] = true
-  dcgLogger('global fetch body ext patch installed')
-  return true
-}
-
-export function installUndiciFetchInterceptor(): boolean {
-  const g = globalThis as InterceptorGlobal
-  const globalFetchPatched = installGlobalFetchPatch()
-  if (g[UNDICI_WRAPPED_KEY]) return true
-
-  const undici = resolveUndici()
-  if (!undici) {
-    dcgLogger('undici.fetch intercept skipped: undici module unavailable', 'error')
-    return globalFetchPatched
-  }
-
-  const originalFetch = undici.fetch
-  if (typeof originalFetch !== 'function') {
-    return globalFetchPatched
-  }
-
-  g[ORIGINAL_UNDICI_FETCH_KEY] = originalFetch
-
-  let callId = 0
-  const wrappedFetch: FetchLike = async function wrappedUndiciFetch(input: unknown, init?: unknown) {
-    const url = getFetchUrl(input)
-    const prepared = await prepareFetchWithPendingLlmBodyExt(input, init)
-    if (!isLikelyLlmFetch(url)) {
-      return originalFetch(prepared.input, prepared.init)
-    }
-
-    const id = ++callId
-    const startedAt = Date.now()
-    try {
-      const response = await originalFetch(prepared.input, prepared.init)
-      return response
-    } catch (e) {
-      dcgLogger(`[undici.fetch #${id}] LLM request failed duration=${Date.now() - startedAt}ms error=${String(e)}`, 'error')
-      throw e
-    }
-  }
-  copyFunctionShape(wrappedFetch, originalFetch)
-
-  try {
-    undici.fetch = wrappedFetch
-  } catch (e) {
-    dcgLogger(`undici.fetch direct patch failed, runtime deps injection will still be attempted: ${String(e)}`, 'error')
-  }
-
-  g[UNDICI_RUNTIME_DEPS_KEY] = {
-    ...g[UNDICI_RUNTIME_DEPS_KEY],
-    Agent: undici.Agent,
-    EnvHttpProxyAgent: undici.EnvHttpProxyAgent,
-    ProxyAgent: undici.ProxyAgent,
-    FormData: undici.FormData,
-    Headers: undici.Headers,
-    Request: undici.Request,
-    Response: undici.Response,
-    fetch: wrappedFetch
-  }
-  g[UNDICI_WRAPPED_KEY] = true
-  dcgLogger(`undici.fetch intercept installed via ${UNDICI_RUNTIME_DEPS_KEY}`)
-  return true
-}

package/src/utils/workspaceFilePaths.ts

@@ -1,18 +0,0 @@
-import os from 'node:os'
-import path from 'node:path'
-
-/**
- * 将正文里的 `~/...` / `~\...` 展开为绝对路径（`path.resolve` 不会处理 `~`）。
- */
-export function expandTildePath(input: string): string {
-  const s = input.trim()
-  if (!s) return s
-  if (s === '~') return os.homedir()
-  if (s.startsWith('~/')) {
-    return path.resolve(os.homedir(), s.slice(2))
-  }
-  if (s.startsWith('~\\')) {
-    return path.resolve(os.homedir(), s.slice(2))
-  }
-  return s
-}