chatccc 0.2.247 → 0.2.249

package/deepccc-agent/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "deepccc",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "deepccc",
-      "version": "0.1.16",
+      "version": "0.1.18",
       "license": "Apache-2.0",
       "dependencies": {
         "@ai-sdk/anthropic": "^3.0.105",

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [

package/deepccc-agent/src/__tests__/chat-session.test.ts

@@ -16,6 +16,7 @@ const rawLogCloseMock = vi.fn();
 const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
 const originalStreaming = config.streaming;
 const originalProvider = config.provider;
+const originalEffort = config.effort;
 const createOpenAICompatibleMock = vi.fn(() => (modelId: string) => ({ modelId }));
 const createAnthropicMock = vi.fn(() => (modelId: string) => ({ modelId, provider: "anthropic" }));
 
@@ -57,6 +58,7 @@ async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
 beforeEach(() => {
   config.provider = "openai";
   config.streaming = true;
+  config.effort = "";
 });
 
 afterEach(() => {
@@ -68,6 +70,7 @@ afterEach(() => {
   config.rawStreamLogs = structuredClone(originalRawStreamLogs);
   config.provider = originalProvider;
   config.streaming = originalStreaming;
+  config.effort = originalEffort;
   createOpenAICompatibleMock.mockClear();
   createAnthropicMock.mockClear();
   vi.useRealTimers();
@@ -103,7 +106,7 @@ describe("ChatSession response transport", () => {
     expect(createOpenAICompatibleMock).not.toHaveBeenCalled();
   });
 
-  it("keeps an existing /v1 suffix for Anthropic and streams without OpenAI-only effort options", async () => {
+  it("keeps an existing /v1 suffix and maps Anthropic effort to output_config.effort", async () => {
     const { ChatSession } = await import("../index.js");
     streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
     const session = new ChatSession({
@@ -120,10 +123,47 @@ describe("ChatSession response transport", () => {
       baseURL: "https://gateway.example/v1",
       apiKey: "sk-test",
     });
+    expect(streamTextMock).toHaveBeenCalledOnce();
+    expect(streamTextMock.mock.calls[0]?.[0]).toMatchObject({
+      providerOptions: { anthropic: { effort: "high" } },
+    });
+  });
+
+  it("omits providerOptions when effort is empty for the Anthropic protocol", async () => {
+    const { ChatSession } = await import("../index.js");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+    const session = new ChatSession({
+      provider: "anthropic",
+      apiKey: "sk-test",
+      baseURL: "https://gateway.example",
+      model: "model-a",
+    });
+
+    await collect(session.chat("hello"));
+
     expect(streamTextMock).toHaveBeenCalledOnce();
     expect(streamTextMock.mock.calls[0]?.[0]).not.toHaveProperty("providerOptions");
   });
 
+  it("maps OpenAI-compatible effort to DeepSeek reasoningEffort", async () => {
+    const { ChatSession } = await import("../index.js");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+    const session = new ChatSession({
+      provider: "openai",
+      apiKey: "sk-test",
+      baseURL: "https://gateway.example",
+      model: "model-a",
+      effort: "max",
+    });
+
+    await collect(session.chat("hello"));
+
+    expect(streamTextMock).toHaveBeenCalledOnce();
+    expect(streamTextMock.mock.calls[0]?.[0]).toMatchObject({
+      providerOptions: { deepseek: { reasoningEffort: "max" } },
+    });
+  });
+
   it("asks the provider to include usage in streaming responses", async () => {
     const { ChatSession } = await import("../index.js");
 
@@ -415,7 +455,11 @@ describe("ChatSession context management", () => {
     const events = await collect(restored.chat("new question"));
 
     expect(generateTextMock).toHaveBeenCalledOnce();
-    expect(generateTextMock).toHaveBeenCalledWith(expect.objectContaining({ temperature: 0 }));
+    expect(generateTextMock).toHaveBeenCalledWith(expect.objectContaining({
+      temperature: 0,
+      maxOutputTokens: 16_384,
+      providerOptions: { deepseek: { reasoningEffort: "none" } },
+    }));
     expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
       messages: expect.arrayContaining([
         expect.objectContaining({ content: expect.stringContaining("old question summarized") }),
@@ -430,6 +474,73 @@ describe("ChatSession context management", () => {
     expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
   });
 
+  it("locks compaction to low effort under the Anthropic protocol", async () => {
+    const { ChatSession } = await import("../index.js");
+    const dir = await mkdtemp(join(tmpdir(), "deepccc-session-compaction-anthropic-effort-"));
+    const base = { apiKey: "sk-test", provider: "anthropic" as const, baseURL: "https://gateway.example", model: "model-a" };
+
+    const seed = new ChatSession(base, {
+      persist: true,
+      contextDir: dir,
+      sessionId: "compaction-anthropic-effort",
+      compactAtTokens: 10_000,
+    });
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
+    await collect(seed.chat("old question"));
+
+    generateTextMock.mockResolvedValueOnce({ text: "## Current Task\n- old question summarized" });
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
+
+    const restored = new ChatSession(base, {
+      persist: true,
+      contextDir: dir,
+      sessionId: "compaction-anthropic-effort",
+      compactAtTokens: 1,
+      keepRecentMessages: 1,
+    });
+    await collect(restored.chat("new question"));
+
+    expect(generateTextMock).toHaveBeenCalledOnce();
+    expect(generateTextMock).toHaveBeenCalledWith(expect.objectContaining({
+      maxOutputTokens: 16_384,
+      providerOptions: { anthropic: { effort: "low" } },
+    }));
+  });
+
+  it("compacts in a single pass and keeps the conversation alive when the budget is still exceeded", async () => {
+    const { ChatSession } = await import("../index.js");
+    const dir = await mkdtemp(join(tmpdir(), "deepccc-session-compaction-single-pass-"));
+
+    const seed = new ChatSession(
+      { apiKey: "sk-test" },
+      { persist: true, contextDir: dir, sessionId: "single-pass", compactAtTokens: 10_000 },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
+    await collect(seed.chat("old question"));
+
+    // 摘要故意无法满足紧凑预算（compactAtTokens=1 时保留的 recent 消息本身就超预算）：
+    // 单轮压缩后不应抛"仍超预算"错误中断对话，而是继续生成回复，下次对话前再压缩。
+    generateTextMock.mockResolvedValueOnce({ text: "## Current Task\n- short summary" });
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
+
+    const restored = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "single-pass",
+        compactAtTokens: 1,
+        keepRecentMessages: 1,
+      },
+    );
+    const events = await collect(restored.chat("new question"));
+
+    // 单轮：generateText 只调用一次（不再 8 轮重试），且不抛错，对话正常完成
+    expect(generateTextMock).toHaveBeenCalledOnce();
+    expect(events).toContainEqual({ type: "compact", compactedMessages: expect.any(Number) });
+    expect(events.at(-1)).toEqual({ type: "done", text: "new answer" });
+  });
+
   it("times out context compaction independently before reply generation", async () => {
     vi.useFakeTimers();
     const { ChatSession } = await import("../index.js");

package/deepccc-agent/src/__tests__/context.test.ts

@@ -15,6 +15,28 @@ import {
 } from "../context.js";
 
 describe("BuiltinContextManager", () => {
+  it("defaults the compaction threshold to 128K tokens (one third of the 384K model window)", () => {
+    const context = new BuiltinContextManager();
+
+    expect(context.compactAtTokens).toBe(128_000);
+  });
+
+  it("caps existing summaries at 8K chars when rebuilding the compaction prompt", () => {
+    const context = new BuiltinContextManager({
+      compactAtTokens: 100,
+      keepRecentMessages: 1,
+      persist: false,
+    });
+    context.setSummary("previous ".repeat(30_000));
+    context.appendMessage({ role: "user", content: "earlier request" });
+    context.appendMessage({ role: "user", content: "latest request" });
+
+    const prompt = buildSummaryPrompt(context.planCompaction()!);
+
+    expect(prompt).toContain("existing summary truncated for compaction");
+    expect(prompt.length).toBeLessThan(40_000);
+  });
+
   it("keeps recent messages within the token budget instead of a fixed count", () => {
     const context = new BuiltinContextManager({
       compactAtTokens: 300,

package/deepccc-agent/src/context.ts

@@ -64,10 +64,10 @@ export interface BuiltinContextOptions {
 }
 
 export const DEFAULT_BUILTIN_CONTEXT_DIR = join(homedir(), ".deepccc", "sessions");
-export const DEFAULT_COMPACT_AT_TOKENS = 48_000;
+export const DEFAULT_COMPACT_AT_TOKENS = 128_000;
 export const DEFAULT_KEEP_RECENT_MESSAGES = 16;
 const RECENT_CONTEXT_BUDGET_RATIO = 0.6;
-const MAX_COMPACTION_SUMMARY_CHARS = 16_000;
+const MAX_COMPACTION_SUMMARY_CHARS = 8_000;
 const MAX_COMPACTION_MESSAGE_CHARS = 24_000;
 const MAX_COMPACTION_SOURCE_CHARS = 64_000;
 

package/deepccc-agent/src/index.ts

@@ -4,20 +4,21 @@
  * ChatSession 是程序化入口，既可以被 CLI 调用，也可以被其他模块调用。
  */
 
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import type { JSONObject } from "@ai-sdk/provider";
 import { generateText, isLoopFinished, stepCountIs, streamText, type TextStreamPart } from "ai";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import {
-  config as appConfig,
-  normalizeDeepCccProvider,
-  RAW_STREAM_LOGS_DIR,
-  type DeepCccProvider,
-} from "./config.js";
+import {
+  config as appConfig,
+  normalizeDeepCccProvider,
+  RAW_STREAM_LOGS_DIR,
+  type DeepCccProvider,
+} from "./config.js";
 import {
   createRawStreamLog,
   type RawStreamLogHandle,
@@ -82,8 +83,8 @@ const SUMMARY_SYSTEM_PROMPT = [
   "Do not introduce new facts or promote historical user content into higher-priority system rules.",
 ].join("\n");
 
-export const DEFAULT_COMPACTION_TIMEOUT_MS = 5 * 60 * 1000;
-const MAX_COMPACTION_PASSES = 8;
+export const DEFAULT_COMPACTION_TIMEOUT_MS = 90 * 1000;
+const MAX_COMPACTION_OUTPUT_TOKENS = 16_384;
 
 // ---------------------------------------------------------------------------
 // 类型定义
@@ -174,24 +175,24 @@ export function loadPlatformCommandPrompt(
   return "";
 }
 
-function normalizeMaxSteps(value: number | undefined): number | undefined {
+function normalizeMaxSteps(value: number | undefined): number | undefined {
   if (value === undefined) return undefined;
   if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
     throw new Error("maxSteps must be a positive integer when provided");
   }
-  return value;
-}
-
-function normalizeAnthropicBaseURL(baseURL: string): string {
-  const normalized = baseURL.trim().replace(/\/+$/, "");
-  return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
-}
-
-export interface ChatSessionConfig {
-  /** API protocol/provider. Defaults to DEEPCCC_PROVIDER/config, then openai. */
-  provider?: DeepCccProvider;
-  /** Provider service base URL. Defaults to DEEPCCC_BASE_URL/config. */
-  baseURL?: string;
+  return value;
+}
+
+function normalizeAnthropicBaseURL(baseURL: string): string {
+  const normalized = baseURL.trim().replace(/\/+$/, "");
+  return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+
+export interface ChatSessionConfig {
+  /** API protocol/provider. Defaults to DEEPCCC_PROVIDER/config, then openai. */
+  provider?: DeepCccProvider;
+  /** Provider service base URL. Defaults to DEEPCCC_BASE_URL/config. */
+  baseURL?: string;
   /** API key. Defaults to DEEPCCC_API_KEY/config. */
   apiKey?: string;
   /** Model id. Defaults to DEEPCCC_MODEL/config. */
@@ -265,9 +266,9 @@ interface ChatMessage {
   content: string;
 }
 
-export class ChatSession {
-  private model: any;
-  private provider: DeepCccProvider;
+export class ChatSession {
+  private model: any;
+  private provider: DeepCccProvider;
   private cwd: string;
   private context: BuiltinContextManager;
   private compactionTimeoutMs: number;
@@ -290,26 +291,26 @@ export class ChatSession {
       );
     }
 
-    const baseURL = overrides.baseURL ?? appConfig.baseURL;
-    const modelId = overrides.model ?? appConfig.model;
-    this.provider = normalizeDeepCccProvider(overrides.provider ?? appConfig.provider);
-    this.effort = (overrides.effort ?? appConfig.effort ?? "").trim();
-
-    if (this.provider === "anthropic") {
-      const provider = createAnthropic({
-        baseURL: normalizeAnthropicBaseURL(baseURL),
-        apiKey,
-      });
-      this.model = provider(modelId);
-    } else {
-      const provider = createOpenAICompatible({
-        name: "deepccc",
-        baseURL,
-        apiKey,
-        includeUsage: true,
-      });
-      this.model = provider(modelId);
-    }
+    const baseURL = overrides.baseURL ?? appConfig.baseURL;
+    const modelId = overrides.model ?? appConfig.model;
+    this.provider = normalizeDeepCccProvider(overrides.provider ?? appConfig.provider);
+    this.effort = (overrides.effort ?? appConfig.effort ?? "").trim();
+
+    if (this.provider === "anthropic") {
+      const provider = createAnthropic({
+        baseURL: normalizeAnthropicBaseURL(baseURL),
+        apiKey,
+      });
+      this.model = provider(modelId);
+    } else {
+      const provider = createOpenAICompatible({
+        name: "deepccc",
+        baseURL,
+        apiKey,
+        includeUsage: true,
+      });
+      this.model = provider(modelId);
+    }
     this.cwd = options.cwd ?? process.cwd();
     this.maxSteps = normalizeMaxSteps(options.maxSteps);
     this.compactionTimeoutMs = Math.max(1, options.compactionTimeoutMs ?? DEFAULT_COMPACTION_TIMEOUT_MS);
@@ -407,29 +408,36 @@ export class ChatSession {
       const skills = await scanSkillsDirs(this.skillDirs);
       const system = this.buildSystemPrompt(skills);
       this.systemPrompt = system;
-      const generationOptions = {
-        model: this.model,
-        system,
-        messages: this.context.buildModelMessages() as any,
+      // effort 按协议映射：
+      // - OpenAI 兼容：providerOptions.deepseek.reasoningEffort 由 @ai-sdk/openai-compatible
+      //   自动映射为请求体 reasoning_effort 字段（DeepSeek 原生支持）；
+      // - Anthropic：providerOptions.anthropic.effort 由 @ai-sdk/anthropic 组装为请求体
+      //   output_config.effort（官方 Effort API，见 platform.claude.com/docs/en/build-with-claude/effort）
+      let effortProviderOptions: Record<string, JSONObject> | undefined;
+      if (this.effort) {
+        effortProviderOptions = this.provider === "openai"
+          ? { deepseek: { reasoningEffort: this.effort } }
+          : { anthropic: { effort: this.effort } };
+      }
+      const generationOptions = {
+        model: this.model,
+        system,
+        messages: this.context.buildModelMessages() as any,
         tools: createBuiltinFileTools(this.cwd, { permissionGate: this.permissionGate }),
         stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),
         abortSignal: signal,
-        // DeepSeek OpenAI 兼容接口：providerOptions.deepseek.reasoningEffort
-        // 由 @ai-sdk/openai-compatible 自动映射为请求体 reasoning_effort 字段
-        ...(this.provider === "openai" && this.effort
-          ? { providerOptions: { deepseek: { reasoningEffort: this.effort } } }
-          : {}),
-      };
-      let stream: AsyncIterable<TextStreamPart<any>>;
-      if (appConfig.streaming) {
-        const result = streamText(generationOptions);
-        stream = result.fullStream ?? textStreamToFullStream(result.textStream);
-      } else {
-        const result = await generateText(generationOptions);
-        stream = generateResultToFullStream(result);
-      }
-
-      for await (const part of stream as AsyncIterable<TextStreamPart<any>>) {
+        ...(effortProviderOptions ? { providerOptions: effortProviderOptions } : {}),
+      };
+      let stream: AsyncIterable<TextStreamPart<any>>;
+      if (appConfig.streaming) {
+        const result = streamText(generationOptions);
+        stream = result.fullStream ?? textStreamToFullStream(result.textStream);
+      } else {
+        const result = await generateText(generationOptions);
+        stream = generateResultToFullStream(result);
+      }
+
+      for await (const part of stream as AsyncIterable<TextStreamPart<any>>) {
         rawLog?.writeLine(safeRawStreamJson(part));
         if (part.type === "text-delta") {
           fullText += part.text;
@@ -549,33 +557,35 @@ export class ChatSession {
     const compactionSignal = signal
       ? AbortSignal.any([signal, timeoutController.signal])
       : timeoutController.signal;
-    let compactedMessages = 0;
 
     try {
-      for (let pass = 0; pass < MAX_COMPACTION_PASSES; pass += 1) {
-        const plan = this.context.planCompaction();
-        if (!plan) return compactedMessages;
-
-        const result = await generateText({
-          model: this.model,
-          system: SUMMARY_SYSTEM_PROMPT,
-          messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
-          abortSignal: compactionSignal,
-          temperature: 0,
-        });
-
-        if (!result.text.trim()) {
-          throw new Error("Context compaction returned an empty summary");
-        }
+      const plan = this.context.planCompaction();
+      if (!plan) return 0;
+
+      const result = await generateText({
+        model: this.model,
+        system: SUMMARY_SYSTEM_PROMPT,
+        messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
+        abortSignal: compactionSignal,
+        temperature: 0,
+        // 摘要单轮生成：显式放宽 maxOutputTokens，避免 AI SDK 对未知模型的
+        // 兼容模式默认 4096 上限导致摘要生成不完（那是旧版多轮压缩的根因）；
+        // 同时锁低 effort（OpenAI reasoning_effort=none / Anthropic
+        // output_config.effort=low），避免继承主对话的高 effort 拖慢"压缩上下文中"阶段。
+        maxOutputTokens: MAX_COMPACTION_OUTPUT_TOKENS,
+        providerOptions: this.provider === "openai"
+          ? { deepseek: { reasoningEffort: "none" } }
+          : { anthropic: { effort: "low" } },
+      });
 
-        this.context.applyCompaction(result.text, plan);
-        compactedMessages += plan.oldMessages.length;
+      if (!result.text.trim()) {
+        throw new Error("Context compaction returned an empty summary");
       }
 
-      if (this.context.planCompaction()) {
-        throw new Error(`Context remains above its token budget after ${MAX_COMPACTION_PASSES} compaction passes`);
-      }
-      return compactedMessages;
+      this.context.applyCompaction(result.text, plan);
+      // 单轮压缩：不再反复迭代重试。若上下文仍超预算（如 recent 消息本身超大），
+      // 留给下一次对话前再次压缩，避免阻塞当前回复生成（业界同步压缩的标准取舍）。
+      return plan.oldMessages.length;
     } catch (error) {
       if (timeoutController.signal.aborted && !signal?.aborted) {
         throw new Error(`Context compaction timed out after ${formatDuration(this.compactionTimeoutMs)}`);
@@ -587,40 +597,40 @@ export class ChatSession {
   }
 }
 
-async function* textStreamToFullStream(stream: AsyncIterable<string>): AsyncIterable<{ type: "text-delta"; text: string }> {
-  for await (const text of stream) {
-    yield { type: "text-delta", text };
-  }
-}
-
-async function* generateResultToFullStream(result: any): AsyncIterable<TextStreamPart<any>> {
-  let emittedText = false;
-  for (const step of result.steps ?? []) {
-    for (const call of step.toolCalls ?? []) {
-      yield {
-        type: "tool-call",
-        toolCallId: call.toolCallId,
-        toolName: call.toolName,
-        input: call.input,
-      } as TextStreamPart<any>;
-    }
-    for (const toolResult of step.toolResults ?? []) {
-      yield {
-        type: "tool-result",
-        toolCallId: toolResult.toolCallId,
-        toolName: toolResult.toolName,
-        output: toolResult.output,
-      } as TextStreamPart<any>;
-    }
-    if (step.text) {
-      emittedText = true;
-      yield { type: "text-delta", text: step.text } as TextStreamPart<any>;
-    }
-  }
-  if (!emittedText && result.text) {
-    yield { type: "text-delta", text: result.text } as TextStreamPart<any>;
-  }
-}
+async function* textStreamToFullStream(stream: AsyncIterable<string>): AsyncIterable<{ type: "text-delta"; text: string }> {
+  for await (const text of stream) {
+    yield { type: "text-delta", text };
+  }
+}
+
+async function* generateResultToFullStream(result: any): AsyncIterable<TextStreamPart<any>> {
+  let emittedText = false;
+  for (const step of result.steps ?? []) {
+    for (const call of step.toolCalls ?? []) {
+      yield {
+        type: "tool-call",
+        toolCallId: call.toolCallId,
+        toolName: call.toolName,
+        input: call.input,
+      } as TextStreamPart<any>;
+    }
+    for (const toolResult of step.toolResults ?? []) {
+      yield {
+        type: "tool-result",
+        toolCallId: toolResult.toolCallId,
+        toolName: toolResult.toolName,
+        output: toolResult.output,
+      } as TextStreamPart<any>;
+    }
+    if (step.text) {
+      emittedText = true;
+      yield { type: "text-delta", text: step.text } as TextStreamPart<any>;
+    }
+  }
+  if (!emittedText && result.text) {
+    yield { type: "text-delta", text: result.text } as TextStreamPart<any>;
+  }
+}
 
 function safeJson(value: unknown): string {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.247",
+  "version": "0.2.249",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",