qwenproxy-cli 1.0.0

package/src/routes/chat/context.ts

@@ -0,0 +1,241 @@
+import { config, type ChatMode } from "../../core/config.ts";
+import { ContextLengthExceededError, ValidationError } from "../../core/errors.ts";
+import { getModelContextWindow } from "../../core/model-registry.ts";
+import {
+  assertPromptWithinLimits,
+  isRequestPersonalizationWithinLimit,
+} from "../../core/prompt-limits.ts";
+import type { Message } from "../../utils/types.ts";
+import { estimateTokenCount } from "../../utils/context-truncation.ts";
+import { deriveSessionId } from "../../utils/session-id.ts";
+import { getLogicalThreadState, consumeToolCapNotice } from "../../services/qwen.ts";
+
+export { estimateTokenCount, getModelContextWindow, deriveSessionId };
+
+export interface FinalContext {
+  finalPrompt: string;
+  sessionId: string | null;
+  existingThread: boolean;
+  shouldResetUpstreamThread: boolean;
+  isNewSession: boolean;
+  useThreadNative: boolean;
+  updateLogicalThread: boolean;
+  chatMode: ChatMode;
+  isThinkingModel: boolean;
+  estimatedTokens: number;
+  modelContextWindow: number;
+  isTitleGenerationRequest: boolean;
+  requestPersonalizationInstruction: string | null;
+  hasExplicitConversationKey: boolean;
+  allowThreadReuse: boolean;
+}
+
+export interface BuildContextParams {
+  messages: Message[];
+  systemPrompt: string;
+  toolInstructions: string;
+  prompt: string;
+  currentPrompt: string;
+  modelId: string;
+  enableThinking: boolean;
+  conversationKey: string | null;
+  hasExplicitConversationKey: boolean;
+  chatMode?: ChatMode;
+}
+
+export async function buildFinalContext(
+  params: BuildContextParams,
+): Promise<FinalContext> {
+  const {
+    messages,
+    systemPrompt,
+    toolInstructions,
+    prompt,
+    currentPrompt,
+    modelId,
+    enableThinking,
+    conversationKey,
+    hasExplicitConversationKey,
+    chatMode = "thread",
+  } = params;
+
+  const modelContextWindow = getModelContextWindow(modelId);
+  const useThreadNative = true;
+  const isTempMode = chatMode === "temp";
+  // A continuation is ANY evidence of a prior turn, not just a plain
+  // role:"assistant" message. Tool-loop clients (Zed/Cline) can send history
+  // with tool/function responses or assistant tool_calls but WITHOUT a plain
+  // assistant entry; misclassifying those as a new session forced the FULL
+  // history to be re-sent on every request (and every chat_in_progress retry)
+  // instead of the thread-native delta.
+  // In temp mode EVERY request is a new (ephemeral) chat, so the whole history
+  // is always sent and no thread state is ever consulted.
+  const isNewSession = isTempMode
+    ? true
+    : !messages.some(isContinuationMessage);
+  const completeInstructions = [systemPrompt.trim(), toolInstructions.trim()]
+    .filter(Boolean)
+    .join("\n\n");
+
+  // Thread reuse is allowed when:
+  // 1. Thread-native mode is active
+  // 2. Either: explicit session_id/conversation_id was provided
+  //    OR: this is a continuation (has assistant messages in history)
+  // This prevents new IDE chats from accidentally reusing old Qwen chats
+  // while still allowing continuations without explicit session_id
+  const allowThreadReuse = isTempMode
+    ? false
+    : useThreadNative && (hasExplicitConversationKey || !isNewSession); // has assistant messages = continuation of existing chat
+
+  // Compute sessionId: only generate a persistent session ID when we have
+  // an explicit conversation key. Otherwise, generate an ephemeral ID for
+  // logging/metrics only (not used for thread reuse). Temp mode never persists
+  // a thread, so it has no session id.
+  const sessionId = isTempMode
+    ? null
+    : (conversationKey || useThreadNative)
+      ? deriveSessionId(
+          messages,
+          conversationKey ? completeInstructions : "",
+          conversationKey ?? "implicit-thread",
+        )
+      : null;
+
+  // Only load existing thread when reuse is allowed
+  const existingThread = allowThreadReuse
+    ? getLogicalThreadState(sessionId)
+    : null;
+
+  const hasTrailingToolResult = detectTrailingToolResult(messages);
+  // Thread-native: send full history when Qwen has no context yet, but preserve
+  // tool-result deltas because the upstream parent chain already owns the call.
+  // Temp mode: always send the FULL history (OpenAI standard).
+  const baseActivePrompt = isTempMode
+    ? prompt
+    : (!existingThread && !hasTrailingToolResult ? prompt : currentPrompt) ||
+      prompt;
+
+  // If the previous turn of this session was closed early at the per-turn
+  // tool-call cap, tell the model so it knows calls beyond the cap were NOT
+  // executed and can re-issue them. The notice is consumed once (it clears
+  // itself) and rides this single turn only. This is a transient system notice,
+  // not the persistent personalization instruction, so it may live in the prompt.
+  const toolCapNotice = consumeToolCapNotice(sessionId)
+    ? `[SYSTEM NOTICE] Your previous response reached the maximum of ${config.retry.maxToolCallsPerTurn} tool calls per turn; any tool calls beyond that limit were NOT executed. Review the tool results below and continue; if you intended more operations, issue them now in smaller batches.\n\n`
+    : "";
+  const activePrompt = toolCapNotice
+    ? toolCapNotice + baseActivePrompt
+    : baseActivePrompt;
+  const isTitleGenerationRequest = detectTitleGenerationRequest(messages);
+  const requestedPersonalization =
+    config.qwen.personalizationFromRequest && !isTitleGenerationRequest;
+  const personalizationInstruction = completeInstructions;
+  const useRequestPersonalization =
+    requestedPersonalization &&
+    isRequestPersonalizationWithinLimit(personalizationInstruction);
+
+  // Agent instructions and tools ride ONLY the account-level personalization
+  // (confirmed before the completion request is sent — the real Qwen client
+  // also never sends a system prompt in the completions payload). When the
+  // channel cannot carry them, fail loud instead of degrading to inline.
+  if (completeInstructions && !useRequestPersonalization) {
+    if (requestedPersonalization) {
+      throw new ContextLengthExceededError(
+        `System instructions and tools (${Buffer.byteLength(personalizationInstruction, "utf8")} bytes) exceed the personalization payload limit (${config.qwen.maxPersonalizationBytes} bytes) and are no longer sent inline. Raise QWEN_MAX_PERSONALIZATION_BYTES or reduce the instruction size.`,
+      );
+    }
+    if (!isTitleGenerationRequest) {
+      throw new ValidationError(
+        "Agent instructions can only be delivered via Qwen account personalization, but QWEN_PERSONALIZATION_FROM_REQUEST is disabled. Re-enable it or remove the system instructions from the request.",
+      );
+    }
+  }
+  const estimatedTokens = estimateTokenCount(
+    completeInstructions,
+    activePrompt,
+  );
+  // Instructions are delivered exclusively via account-level personalization;
+  // the prompt carries only the conversation. Title generation does not sync
+  // personalization, so it keeps its (small) instructions inline.
+  const finalPrompt =
+    isTitleGenerationRequest && completeInstructions
+      ? `${completeInstructions}\n${activePrompt}`
+      : activePrompt;
+
+  // Truncation is deferred to tryCreateStreamWithRetry, which runs after the
+  // account is selected and the real model context window has been synced from
+  // Qwen's /api/models catalog. The early context build only performs the byte
+  // limit check; the authoritative token check happens downstream.
+  assertPromptWithinLimits(finalPrompt, modelId, { checkModelContext: false });
+
+  const isThinkingModel = enableThinking;
+  const shouldResetUpstreamThread = false;
+
+  return {
+    finalPrompt,
+    sessionId,
+    existingThread: !!existingThread,
+    shouldResetUpstreamThread,
+    isNewSession,
+    useThreadNative,
+    // Thread state is only persisted in thread mode (temp chats are ephemeral).
+    updateLogicalThread: isTempMode ? false : useThreadNative,
+    chatMode,
+    isThinkingModel,
+    estimatedTokens,
+    modelContextWindow,
+    isTitleGenerationRequest,
+    requestPersonalizationInstruction: useRequestPersonalization
+      ? personalizationInstruction
+      : null,
+    hasExplicitConversationKey,
+    allowThreadReuse,
+  };
+}
+
+function isContinuationMessage(message: Message): boolean {
+  return (
+    message.role === "assistant" ||
+    message.role === "tool" ||
+    message.role === "function" ||
+    (Array.isArray(message.tool_calls) && message.tool_calls.length > 0)
+  );
+}
+
+function extractMessageText(message: Message | undefined): string {
+  if (!message) return "";
+  const content: unknown = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part: any) => (part?.type === "text" ? part.text || "" : ""))
+      .join("\n");
+  }
+  if (content && typeof content === "object") return JSON.stringify(content);
+  return "";
+}
+
+function detectTrailingToolResult(messages: Message[]): boolean {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const role = messages[i].role;
+    if (role === "system") continue;
+    return role === "tool" || role === "function";
+  }
+  return false;
+}
+
+function detectTitleGenerationRequest(messages: Message[]): boolean {
+  if (messages.length < 2) return false;
+  const last = messages[messages.length - 1];
+  if (last?.role !== "user") return false;
+
+  const text = extractMessageText(last).toLowerCase();
+  if (!text) return false;
+
+  // The first pattern is strictly subsumed by the second (which does not
+  // require the leading verb), so it is redundant and was removed.
+  return (
+    /\btitle\b[\s\S]{0,80}\bconversation\b/.test(text) ||
+    /\bconversation\b[\s\S]{0,80}\btitle\b/.test(text)
+  );
+}

package/src/routes/chat/errors.ts

@@ -0,0 +1,85 @@
+/**
+ * Parse a non-SSE upstream body that may contain a Qwen error payload.
+ * Returns null when the body is not a recognized error document.
+ */
+export interface ParsedQwenErrorPayload {
+  code: string;
+  details: string;
+  message: string;
+  status: number;
+}
+
+function isWafChallenge(value: string): boolean {
+  const normalized = value.toLowerCase();
+  return (
+    normalized.includes("aliyun_waf") ||
+    normalized.includes("_____tmd_____") ||
+    normalized.includes("fail_sys_user_validate") ||
+    normalized.includes("rgv587_error") ||
+    normalized.includes("denyfromx5") ||
+    normalized.includes("captcha") ||
+    normalized.includes("security verification")
+  );
+}
+
+/**
+ * Parse an upstream response that arrived before any SSE event. The returned
+ * details are sanitized so an HTML WAF page is never sent back to API clients.
+ */
+export function parseQwenErrorPayload(
+  raw: string,
+): ParsedQwenErrorPayload | null {
+  const text = raw.trim();
+  if (!text || text.startsWith("data:")) return null;
+
+  try {
+    const payload = JSON.parse(text);
+    if (payload && payload.success === false) {
+      const code = payload.data?.code || payload.code || "UpstreamError";
+      const details =
+        payload.data?.details || payload.message || "Qwen returned an error";
+      const wait =
+        payload.data?.num !== undefined
+          ? ` Wait about ${payload.data.num} hour(s) before trying again.`
+          : "";
+      const status =
+        code === "RateLimited" ? 429 : code === "Not_Found" ? 404 : 502;
+      return {
+        code,
+        details,
+        message: `Qwen upstream error: ${code}: ${details}.${wait}`,
+        status,
+      };
+    }
+    if (payload && payload.error) {
+      const error = payload.error;
+      const code =
+        typeof error === "object" && error?.code
+          ? error.code
+          : payload.code || "UpstreamError";
+      const details =
+        typeof error === "string"
+          ? error
+          : error.details || error.message || JSON.stringify(error);
+      return {
+        code,
+        details,
+        message: `Qwen upstream error: ${code}: ${details}`,
+        status: 502,
+      };
+    }
+  } catch {
+    const waf = isWafChallenge(text);
+    const details = waf
+      ? "Qwen returned an anti-bot challenge instead of an SSE response."
+      : "Qwen returned a non-SSE response before generation started.";
+    return {
+      code: waf ? "waf_challenge" : "non_sse_response",
+      details,
+      message: `Qwen upstream error: ${details}`,
+      status: 502,
+    };
+  }
+
+  return null;
+}

package/src/routes/chat/helpers.ts

@@ -0,0 +1,268 @@
+import { Usage } from "../../utils/types.ts";
+
+export interface DeltaResult {
+  delta: string;
+  matchedContent: string;
+  contentLength: number;
+  contentSuffix: string;
+}
+
+function buildDeltaResult(delta: string, matchedContent: string): DeltaResult {
+  return {
+    delta,
+    matchedContent,
+    contentLength: matchedContent.length,
+    contentSuffix: matchedContent.slice(-32),
+  };
+}
+
+export function getIncrementalDelta(
+  oldStr: string,
+  newStr: string,
+  previousLength = oldStr.length,
+  previousSuffix = oldStr.slice(-32),
+): DeltaResult {
+  if (!oldStr) {
+    return buildDeltaResult(newStr, newStr);
+  }
+  if (newStr === oldStr) {
+    return buildDeltaResult("", oldStr);
+  }
+
+  // Fast path for cumulative Qwen chunks: validate the old boundary using a
+  // short suffix instead of scanning the whole previous content with startsWith.
+  // Using 32-byte window (O(1)) since Qwen streams with incremental_output=true.
+  if (newStr.length > previousLength && previousLength > 0) {
+    const checkLen = Math.min(32, previousLength, previousSuffix.length);
+    const expectedSuffix = previousSuffix.slice(-checkLen);
+    const actualSuffix = newStr.slice(
+      previousLength - checkLen,
+      previousLength,
+    );
+
+    if (expectedSuffix === actualSuffix) {
+      return buildDeltaResult(newStr.slice(previousLength), newStr);
+    }
+  }
+
+  if (newStr.length >= oldStr.length && newStr.startsWith(oldStr)) {
+    return buildDeltaResult(newStr.substring(oldStr.length), newStr);
+  }
+
+  // Heuristic to detect if newStr is cumulative or incremental. Compare in
+  // small segments first to reduce per-character work on long responses.
+  const scanWindow = Math.min(2000, oldStr.length);
+  let commonPrefixLen = 0;
+  const maxLen = Math.min(scanWindow, newStr.length);
+  const segmentLen = 64;
+
+  while (commonPrefixLen + segmentLen <= maxLen) {
+    if (
+      oldStr.slice(commonPrefixLen, commonPrefixLen + segmentLen) !==
+      newStr.slice(commonPrefixLen, commonPrefixLen + segmentLen)
+    ) {
+      break;
+    }
+    commonPrefixLen += segmentLen;
+  }
+
+  while (
+    commonPrefixLen < maxLen &&
+    oldStr[commonPrefixLen] === newStr[commonPrefixLen]
+  ) {
+    commonPrefixLen++;
+  }
+
+  const threshold = Math.min(scanWindow, 4);
+  if (commonPrefixLen >= threshold) {
+    return buildDeltaResult(newStr.substring(commonPrefixLen), newStr);
+  }
+
+  // Treat as strictly incremental to avoid false-positive corruptions
+  return buildDeltaResult(newStr, oldStr + newStr);
+}
+
+export function formatThinkingSummaryContent(delta: any): string {
+  const titles = Array.isArray(delta?.extra?.summary_title?.content)
+    ? delta.extra.summary_title.content.filter(
+        (item: unknown): item is string => typeof item === "string",
+      )
+    : [];
+  const thoughts = Array.isArray(delta?.extra?.summary_thought?.content)
+    ? delta.extra.summary_thought.content.filter(
+        (item: unknown): item is string => typeof item === "string",
+      )
+    : [];
+
+  const sectionCount = Math.max(titles.length, thoughts.length);
+  const sections: string[] = [];
+
+  for (let i = 0; i < sectionCount; i++) {
+    const title = titles[i]?.trim() || "";
+    const thought = thoughts[i]?.trim() || "";
+
+    if (title && thought) {
+      sections.push(`**${title}**\n\n${thought}`);
+    } else if (title) {
+      sections.push(`**${title}**`);
+    } else if (thought) {
+      sections.push(thought);
+    }
+  }
+
+  return sections.join("\n\n");
+}
+
+export function isAbortError(err: unknown): boolean {
+  if (err instanceof DOMException) {
+    return err.name === "AbortError";
+  }
+
+  if (!err || typeof err !== "object") return false;
+
+  const maybeError = err as { name?: unknown; message?: unknown };
+  const name = maybeError.name;
+  const message = maybeError.message;
+
+  return (
+    name === "AbortError" ||
+    (typeof message === "string" && /abort(ed)?/i.test(message))
+  );
+}
+
+export function shouldSuppressStreamAbort(
+  err: unknown,
+  clientDisconnected: boolean,
+  requestAborted: boolean,
+  streamStillRegistered: boolean,
+): boolean {
+  return (
+    isAbortError(err) &&
+    (clientDisconnected || requestAborted || !streamStillRegistered)
+  );
+}
+
+export interface UsageAccumulator {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  hasRealPromptTokens: boolean;
+  hasRealCompletionTokens: boolean;
+  hasRealTotalTokens: boolean;
+  cachedPromptTokens: number;
+  promptTextTokens?: number;
+  reasoningTokens?: number;
+  completionTextTokens?: number;
+}
+
+function asFiniteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+export function createUsageAccumulator(
+  estimatedPromptTokens: number,
+): UsageAccumulator {
+  return {
+    promptTokens: estimatedPromptTokens,
+    completionTokens: 0,
+    totalTokens: estimatedPromptTokens,
+    hasRealPromptTokens: false,
+    hasRealCompletionTokens: false,
+    hasRealTotalTokens: false,
+    cachedPromptTokens: 0,
+  };
+}
+
+export function applyUpstreamUsage(
+  accumulator: UsageAccumulator,
+  candidate: unknown,
+): void {
+  if (!candidate || typeof candidate !== "object") return;
+
+  const usage = candidate as Record<string, unknown>;
+  const promptTokens = asFiniteNumber(usage.input_tokens);
+  const completionTokens = asFiniteNumber(usage.output_tokens);
+  const totalTokens = asFiniteNumber(usage.total_tokens);
+
+  if (promptTokens !== null) {
+    accumulator.promptTokens = promptTokens;
+    accumulator.hasRealPromptTokens = true;
+  }
+
+  if (completionTokens !== null) {
+    accumulator.completionTokens = completionTokens;
+    accumulator.hasRealCompletionTokens = true;
+  }
+
+  if (totalTokens !== null) {
+    accumulator.totalTokens = totalTokens;
+    accumulator.hasRealTotalTokens = true;
+  }
+
+  const promptTokensDetails =
+    usage.prompt_tokens_details &&
+    typeof usage.prompt_tokens_details === "object"
+      ? (usage.prompt_tokens_details as Record<string, unknown>)
+      : null;
+  const inputTokensDetails =
+    usage.input_tokens_details && typeof usage.input_tokens_details === "object"
+      ? (usage.input_tokens_details as Record<string, unknown>)
+      : null;
+  const outputTokensDetails =
+    usage.output_tokens_details &&
+    typeof usage.output_tokens_details === "object"
+      ? (usage.output_tokens_details as Record<string, unknown>)
+      : null;
+
+  const cachedTokens = asFiniteNumber(promptTokensDetails?.cached_tokens);
+  if (cachedTokens !== null) {
+    accumulator.cachedPromptTokens = cachedTokens;
+  }
+
+  const promptTextTokens = asFiniteNumber(inputTokensDetails?.text_tokens);
+  if (promptTextTokens !== null) {
+    accumulator.promptTextTokens = promptTextTokens;
+  }
+
+  const reasoningTokens = asFiniteNumber(outputTokensDetails?.reasoning_tokens);
+  if (reasoningTokens !== null) {
+    accumulator.reasoningTokens = reasoningTokens;
+  }
+
+  const completionTextTokens = asFiniteNumber(outputTokensDetails?.text_tokens);
+  if (completionTextTokens !== null) {
+    accumulator.completionTextTokens = completionTextTokens;
+  }
+}
+
+export function buildUsage(accumulator: UsageAccumulator): Usage {
+  const usage: Usage = {
+    prompt_tokens: accumulator.promptTokens,
+    completion_tokens: accumulator.completionTokens,
+    total_tokens: accumulator.hasRealTotalTokens
+      ? accumulator.totalTokens
+      : accumulator.promptTokens + accumulator.completionTokens,
+    prompt_tokens_details: {
+      cached_tokens: accumulator.cachedPromptTokens,
+      ...(accumulator.promptTextTokens !== undefined
+        ? { text_tokens: accumulator.promptTextTokens }
+        : {}),
+    },
+  };
+
+  if (
+    accumulator.reasoningTokens !== undefined ||
+    accumulator.completionTextTokens !== undefined
+  ) {
+    usage.completion_tokens_details = {
+      ...(accumulator.reasoningTokens !== undefined
+        ? { reasoning_tokens: accumulator.reasoningTokens }
+        : {}),
+      ...(accumulator.completionTextTokens !== undefined
+        ? { text_tokens: accumulator.completionTextTokens }
+        : {}),
+    };
+  }
+
+  return usage;
+}