qwenproxy-cli 1.0.0

package/src/types/ali-oss.d.ts

@@ -0,0 +1,32 @@
+declare module "ali-oss" {
+  interface OSSOptions {
+    region?: string;
+    accessKeyId: string;
+    accessKeySecret: string;
+    stsToken?: string;
+    bucket?: string;
+    endpoint?: string;
+    secure?: boolean;
+    refreshSTSToken?: () => Promise<{
+      accessKeyId: string;
+      accessKeySecret: string;
+      stsToken: string;
+    }>;
+    refreshSTSTokenInterval?: number;
+  }
+
+  interface PutOptions {
+    headers?: Record<string, string>;
+  }
+
+  class OSS {
+    constructor(options: OSSOptions);
+    put(
+      name: string,
+      file: Buffer | string,
+      options?: PutOptions,
+    ): Promise<any>;
+  }
+
+  export default OSS;
+}

package/src/utils/context-truncation.ts

@@ -0,0 +1,84 @@
+/**
+ * Heuristic token estimation.
+ *
+ * Accepts one or more string parts so callers can avoid concatenating large
+ * strings just to estimate them (the parts are accumulated before a single
+ * final Math.ceil, keeping the result identical to the concatenated form).
+ */
+export function estimateTokenCount(...parts: string[]): number {
+  let tokens = 0;
+  for (const part of parts) {
+    if (part) tokens += estimatePart(part);
+  }
+  return Math.ceil(tokens);
+}
+
+function estimatePart(text: string): number {
+  let tokens = 0;
+  let i = 0;
+  const n = text.length;
+
+  while (i < n) {
+    const c = text.charCodeAt(i);
+
+    // Fast path: ASCII (the overwhelmingly common case in OpenAI payloads).
+    // charCodeAt avoids the per-char string allocation and codePointAt decode.
+    if (c < 0x80) {
+      if (c >= 0x20 && c <= 0x7e) {
+        // Printable ASCII: structural characters weigh more than prose.
+        tokens +=
+          c === 0x7b || // {
+          c === 0x7d || // }
+          c === 0x5b || // [
+          c === 0x5d || // ]
+          c === 0x22 || // "
+          c === 0x3a || // :
+          c === 0x2c || // ,
+          c === 0x3b || // ;
+          c === 0x28 || // (
+          c === 0x29 || // )
+          c === 0x2f || // /
+          c === 0x5c // \
+            ? 0.4
+            : 0.25;
+      } else if (c === 0x0a || c === 0x0d || c === 0x09) {
+        tokens += 0.2; // \n \r \t
+      } else {
+        tokens += 1.0; // remaining control characters
+      }
+      i += 1;
+      continue;
+    }
+
+    // Non-ASCII path: code-point based heuristics (CJK/kana/hangul/other).
+    const codePoint = text.codePointAt(i) || 0;
+
+    // CJK Unified Ideographs (U+4E00-U+9FFF)
+    if (codePoint >= 0x4e00 && codePoint <= 0x9fff) {
+      tokens += 1.5;
+      i += 1;
+    }
+    // CJK Extension A/B (U+3400-U+2A6DF)
+    else if (codePoint >= 0x3400 && codePoint <= 0x2a6df) {
+      tokens += 1.5;
+      i += codePoint > 0xffff ? 2 : 1;
+    }
+    // Hiragana/Katakana (U+3040-U+30FF)
+    else if (codePoint >= 0x3040 && codePoint <= 0x30ff) {
+      tokens += 1.2;
+      i += 1;
+    }
+    // Hangul (U+AC00-U+D7AF)
+    else if (codePoint >= 0xac00 && codePoint <= 0xd7af) {
+      tokens += 1.3;
+      i += 1;
+    }
+    // Other Unicode (emoji, symbols, etc.)
+    else {
+      tokens += 1.0;
+      i += codePoint > 0xffff ? 2 : 1;
+    }
+  }
+
+  return tokens;
+}

package/src/utils/json.ts

@@ -0,0 +1,380 @@
+import { logger } from "../core/logger.js";
+
+const isDebug = process.env.TOOLCALL_DEBUG === "1";
+
+function sanitizeAndBalance(input: string): {
+  result: string;
+  openBraces: number;
+  openBrackets: number;
+  recoveredUnclosedString: boolean;
+  /** Opening tokens `{`/`[` in the order they were opened (LIFO close order). */
+  openStack: string[];
+} {
+  let out = "";
+  let openBraces = 0;
+  let openBrackets = 0;
+  let openStack: string[] = [];
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (escaped) {
+      const validEscapes = ["n", "r", "t", "u", '"', "\\", "/"];
+      if (validEscapes.includes(char)) {
+        if (char === "u") {
+          const next4 = input.substring(i + 1, i + 5);
+          out += /^[0-9a-fA-F]{4}$/.test(next4) ? "\\" + char : "\\\\" + char;
+        } else if (["n", "r", "t"].includes(char)) {
+          // Local check: only double-escape if the 2 chars before this
+          // backslash form a Windows drive letter + colon (e.g. C:\, D:/).
+          // Scanning the whole input causes false positives with URLs
+          // like https:// or paths embedded elsewhere in the string.
+          const isWinPath = i >= 2 && /[a-zA-Z]:/.test(input.substring(i - 2, i));
+          const nextChar = input[i + 1] || "";
+          out +=
+            isWinPath && /^[a-zA-Z0-9]/.test(nextChar)
+              ? "\\\\" + char
+              : "\\" + char;
+        } else {
+          out += "\\" + char;
+        }
+      } else {
+        out += "\\\\" + char;
+      }
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      out += char;
+      continue;
+    }
+    if (inString) {
+      if (char === "\n") out += "\\n";
+      else if (char === "\r") out += "\\r";
+      else if (char === "\t") out += "\\t";
+      else if (char.charCodeAt(0) < 32)
+        out += "\\u" + char.charCodeAt(0).toString(16).padStart(4, "0");
+      else out += char;
+    } else {
+      out += char;
+      if (char === "{") {
+        openBraces++;
+        openStack.push("{");
+      }
+      if (char === "}") {
+        openBraces--;
+        openStack.pop();
+      }
+      if (char === "[") {
+        openBrackets++;
+        openStack.push("[");
+      }
+      if (char === "]") {
+        openBrackets--;
+        openStack.pop();
+      }
+    }
+  }
+
+  let recoveredUnclosedString = false;
+  if (escaped) {
+    out += "\\";
+  }
+  if (inString) {
+    out += '"';
+    recoveredUnclosedString = true;
+  }
+
+  return { result: out, openBraces, openBrackets, recoveredUnclosedString, openStack };
+}
+
+/**
+ * Close unterminated containers in LIFO order (reverse of how they were
+ * opened). Appending all `]` then all `}` (the old counting-only approach)
+ * produces invalid JSON whenever an array is opened and then an object is
+ * opened inside it before truncation, e.g.
+ * `{"a":[{"old_text":"start` needs `}],}}` and not `]}}}`.
+ */
+function closeBraces(
+  input: string,
+  openBraces: number,
+  openBrackets: number,
+  openStack: string[],
+): string {
+  let out = input;
+  for (let i = openStack.length - 1; i >= 0; i--) {
+    out += openStack[i] === "{" ? "}" : "]";
+  }
+  if (openBraces > 0 || openBrackets > 0) {
+    // Open tokens shorter than the counted opens (no stack entries for them)
+    // cannot happen since the stack mirrors the counts; keep the historical
+    // count-based close as a safety net for callers without a stack.
+    if (openStack.length === 0) {
+      if (openBrackets > 0) out += "]".repeat(openBrackets);
+      if (openBraces > 0) out += "}".repeat(openBraces);
+    }
+  }
+  return out;
+}
+
+/**
+ * Fixes missing opening quotes in JSON values.
+ * Handles cases like: {"key": value_without_quotes"}
+ * Upstream: a63f054, 9328bde
+ */
+function fixMissingOpeningQuotes(input: string): string {
+  let out = input;
+  let prev: string;
+  do {
+    prev = out;
+    // Pattern 1: {"key": value"} or {key: value"}
+    out = out.replace(
+      /([{,[]\s*"[a-zA-Z_][\w]*"\s*:\s*)([^"\s,}\]][^"\n]*?)"([\s,}\]])/g,
+      '$1"$2"$3',
+    );
+    out = out.replace(
+      /([{,[]\s*[a-zA-Z_][\w]*\s*:\s*)([^"\s,}\]][^"\n]*?)"([\s,}\]])/g,
+      '$1"$2"$3',
+    );
+    // Pattern 2: {: value"} - upstream 9328bde
+    out = out.replace(/(:\s*)([A-Za-z_][\w.-]*?)"([\s,}\]])/g, '$1"$2"$3');
+  } while (out !== prev);
+  return out;
+}
+
+export function robustParseJSON(str: string): any {
+  if (isDebug) {
+    logger.debug("[json] robustParseJSON: starting", {
+      inputLength: str.length,
+      inputPreview: str.substring(0, 200),
+    });
+  }
+
+  let sanitized = str.trim();
+  sanitized = sanitized
+    .replace(/^```json\s*/, "")
+    .replace(/```$/, "")
+    .trim();
+
+  const firstBrace = sanitized.indexOf("{");
+  if (firstBrace === -1) {
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: no opening brace found");
+    }
+    return null;
+  }
+
+  let jsonPart = sanitized.substring(firstBrace);
+  try {
+    const result = JSON.parse(jsonPart);
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: direct parse succeeded", {
+        resultType: typeof result,
+        resultPreview: JSON.stringify(result).substring(0, 200),
+      });
+    }
+    return result;
+  } catch (e) {
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: direct parse failed", {
+        error: e instanceof Error ? e.message : String(e),
+      });
+    }
+    // Fix double-escaped quotes (e.g., \\" -> ") only after direct parse
+    // fails, to avoid corrupting valid JSON with legitimate \\ sequences.
+    jsonPart = jsonPart.replace(/\\\\"/g, '\\"');
+  }
+
+  let currentJson = jsonPart.replace(
+    /([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)(\s*:)/g,
+    '$1"$2"$3',
+  );
+  currentJson = currentJson.replace(
+    /([{,]\s*)"([a-zA-Z0-9_]+)"\s*:\s*"\2"\s*:/g,
+    '$1"$2":',
+  );
+  currentJson = currentJson.replace(
+    /([{,]\s*)([a-zA-Z0-9_]+)\s*:\s*\2\s*:/g,
+    "$1$2:",
+  );
+
+  // Fix missing opening quotes in values (upstream: a63f054, 9328bde)
+  currentJson = fixMissingOpeningQuotes(currentJson);
+
+  // Handle unquoted string values after colon (e.g., "command":export CI=true)
+  // Matches: "key":value_without_quotes until comma, closing brace, or end
+  currentJson = currentJson.replace(
+    /"([a-zA-Z0-9_]+)":\s*([^"\s{\[\],}][^,}\]]*)/g,
+    (match, key, value) => {
+      // Don't quote if it's a number, boolean, or null
+      if (/^(true|false|null|\d+(\.\d+)?)$/.test(value.trim())) {
+        return match;
+      }
+      return `"${key}":"${value.trim()}"`;
+    },
+  );
+
+  try {
+    const result = JSON.parse(currentJson);
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: quote-fix parse succeeded", {
+        resultType: typeof result,
+        resultPreview: JSON.stringify(result).substring(0, 200),
+      });
+    }
+    return result;
+  } catch (e) {
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: quote-fix parse failed", {
+        error: e instanceof Error ? e.message : String(e),
+      });
+    }
+    /* continue */
+  }
+
+  let cleaned = currentJson.trim();
+  while (
+    cleaned.length > 0 &&
+    !/[}\]"0-9a-z]/i.test(cleaned[cleaned.length - 1])
+  ) {
+    cleaned = cleaned.slice(0, -1).trim();
+  }
+
+  const {
+    result: fixedJson,
+    openBraces,
+    openBrackets,
+    recoveredUnclosedString,
+    openStack: fixedJsonOpenStack,
+  } = sanitizeAndBalance(cleaned);
+
+  if (isDebug && recoveredUnclosedString) {
+    logger.debug(
+      "[json] robustParseJSON: recovered unclosed string at end of input",
+      {
+        originalPreview: cleaned.substring(0, 150),
+      },
+    );
+  }
+
+  let lastBalancedIndex = -1;
+
+  {
+    let ob = 0,
+      bk = 0,
+      ins = false,
+      esc = false;
+    for (let i = 0; i < fixedJson.length; i++) {
+      const c = fixedJson[i];
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (c === "\\") {
+        esc = true;
+        continue;
+      }
+      if (c === '"') {
+        ins = !ins;
+        continue;
+      }
+      if (!ins) {
+        if (c === "{") ob++;
+        if (c === "}") ob--;
+        if (c === "[") bk++;
+        if (c === "]") bk--;
+        if (ob === 0 && bk === 0) lastBalancedIndex = i;
+      }
+    }
+  }
+
+  let tempJson = fixedJson;
+  if (
+    lastBalancedIndex !== -1 &&
+    (openBraces !== 0 ||
+      openBrackets !== 0 ||
+      fixedJson.length > lastBalancedIndex + 1)
+  ) {
+    tempJson = fixedJson.substring(0, lastBalancedIndex + 1);
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: truncated to balanced index", {
+        lastBalancedIndex,
+        originalLength: fixedJson.length,
+        truncatedLength: tempJson.length,
+      });
+    }
+  } else if (openBraces > 0 || openBrackets > 0) {
+    tempJson = closeBraces(
+      fixedJson,
+      openBraces,
+      openBrackets,
+      fixedJsonOpenStack,
+    );
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: closed braces", {
+        openBraces,
+        openBrackets,
+        resultLength: tempJson.length,
+      });
+    }
+  }
+
+  try {
+    const result = JSON.parse(tempJson);
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: balanced-parse succeeded", {
+        resultType: typeof result,
+        resultPreview: JSON.stringify(result).substring(0, 200),
+      });
+    }
+    return result;
+  } catch (e) {
+    if (isDebug) {
+      logger.debug("[json] robustParseJSON: balanced-parse failed", {
+        error: e instanceof Error ? e.message : String(e),
+      });
+    }
+    let aggressive = fixedJson.trim();
+    if (aggressive.endsWith(",")) aggressive = aggressive.slice(0, -1);
+    const {
+      result: aggFixed,
+      openBraces: ob,
+      openBrackets: bk,
+      recoveredUnclosedString: aggRecovered,
+      openStack: aggOpenStack,
+    } = sanitizeAndBalance(aggressive);
+
+    if (isDebug && aggRecovered) {
+      logger.debug(
+        "[json] robustParseJSON: aggressive recovery of unclosed string",
+        {
+          originalPreview: aggressive.substring(0, 150),
+        },
+      );
+    }
+
+    try {
+      const result = JSON.parse(closeBraces(aggFixed, ob, bk, aggOpenStack));
+      if (isDebug) {
+        logger.debug("[json] robustParseJSON: aggressive-parse succeeded", {
+          resultType: typeof result,
+          resultPreview: JSON.stringify(result).substring(0, 200),
+        });
+      }
+      return result;
+    } catch {
+      if (isDebug) {
+        logger.debug("[json] robustParseJSON: all parse attempts failed", {
+          originalError: e instanceof Error ? e.message : String(e),
+        });
+      }
+      throw e;
+    }
+  }
+}

package/src/utils/session-id.ts

@@ -0,0 +1,37 @@
+import { createHash } from "crypto";
+import type { Message } from "./types.js";
+
+/**
+ * Derive a deterministic session ID from a caller-provided conversation key
+ * plus the conversation's anchoring content.
+ */
+export function deriveSessionId(
+  messages: Message[],
+  systemPrompt: string = "",
+  conversationKey?: string,
+): string {
+  const firstUser = messages.find((m) => m.role === "user");
+  const anchor = [
+    conversationKey?.trim(),
+    systemPrompt.trim(),
+    extractTextContent(firstUser),
+  ]
+    .filter((part) => part && part.length > 0)
+    .join("|");
+  const hash = createHash("sha256").update(anchor).digest("hex").slice(0, 16);
+  return `sess_${hash}`;
+}
+
+function extractTextContent(msg: Message | undefined): string {
+  if (!msg || !msg.content) return "";
+  if (typeof msg.content === "string") return msg.content;
+
+  const content = msg.content as any;
+  if (Array.isArray(content)) {
+    return content
+      .filter((p: any) => p?.type === "text")
+      .map((p: any) => p.text || "")
+      .join(" ");
+  }
+  return "";
+}

package/src/utils/tool-call-guard.ts

@@ -0,0 +1,85 @@
+import type { Message } from "./types.ts";
+
+/**
+ * Detects tool calls that were already executed (identical name + arguments)
+ * earlier in the conversation and returns a short system reminder to be
+ * appended to the prompt. This breaks the re-read/re-inspect loops where the
+ * model keeps calling the same tool turn after turn instead of answering.
+ *
+ * The reminder is prompt-only and does not alter caching, session identity or
+ * the upstream thread.
+ *
+ * @param messages - Full message history (assistant tool_calls + tool/function results).
+ * @param threshold - Minimum number of identical executions before reminding.
+ * @returns Reminder text to append to the prompt, or null when the history is clean.
+ */
+export function buildRepeatedToolCallReminder(
+  messages: Message[] | null | undefined,
+  threshold = 2,
+): string | null {
+  if (!messages || messages.length === 0 || threshold < 2) return null;
+
+  // Canonical key: tool name + normalized arguments (object key order ignored).
+  const occurrences = new Map<string, number>();
+  let lastToolCallTurnIndex = -1;
+
+  for (let i = 0; i < messages.length; i++) {
+    const calls = messages[i]?.tool_calls;
+    if (!calls || calls.length === 0) continue;
+    lastToolCallTurnIndex = i;
+    for (const call of calls) {
+      const key = toolCallKey(call.function?.name, call.function?.arguments);
+      occurrences.set(key, (occurrences.get(key) ?? 0) + 1);
+    }
+  }
+
+  if (lastToolCallTurnIndex < 0) return null;
+
+  const lastCalls = messages[lastToolCallTurnIndex].tool_calls ?? [];
+  const reminders: string[] = [];
+
+  for (const call of lastCalls) {
+    const key = toolCallKey(call.function?.name, call.function?.arguments);
+    const count = occurrences.get(key) ?? 0;
+    if (count >= threshold) {
+      reminders.push(
+        `[SYSTEM REMINDER] You have already executed the tool call "${call.function?.name}" ${count} time(s) in this conversation with exactly the same arguments, and its result is already in the history. Do NOT call it again: use the existing result and write the final answer now. If the earlier attempts were rejected, do not repeat them either; answer directly.`,
+      );
+    }
+  }
+
+  return reminders.length > 0
+    ? reminders.join("\n\n")
+    : null;
+}
+
+function toolCallKey(name: string | undefined, rawArgs: string | undefined): string {
+  const toolName = typeof name === "string" ? name : "";
+  const raw = typeof rawArgs === "string" ? rawArgs : "";
+  let parsed: unknown = raw;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    // Unparseable payloads fall back to the raw string as the key.
+  }
+  return `${toolName}|${JSON.stringify(canonicalize(parsed))}`;
+}
+
+/**
+ * Deep-normalizes JSON values so that argument objects with different key
+ * orders or whitespace still produce the same canonical key.
+ */
+function canonicalize(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  if (value && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    const result: Record<string, unknown> = {};
+    for (const key of Object.keys(record).sort()) {
+      result[key] = canonicalize(record[key]);
+    }
+    return result;
+  }
+  return value;
+}