chatccc 0.2.252 → 0.2.253

package/dist/deepccc-agent/src/session-select.js

@@ -0,0 +1,23 @@
+import { DEFAULT_BUILTIN_CONTEXT_DIR, getBuiltinContextSession, latestBuiltinSessionForCwd, newBuiltinSessionId, normalizeBuiltinSessionId, } from "./context.js";
+export function resolveBuiltinSession(options) {
+    const contextDir = options.contextDir ?? DEFAULT_BUILTIN_CONTEXT_DIR;
+    if (options.resume === true) {
+        const latest = latestBuiltinSessionForCwd(options.cwd, contextDir);
+        if (!latest) {
+            throw new Error(`No resumable DeepCCC session found for cwd: ${options.cwd}`);
+        }
+        return { mode: "resumed", sessionId: latest.sessionId };
+    }
+    if (typeof options.resume === "string") {
+        const sessionId = normalizeBuiltinSessionId(options.resume);
+        const existing = getBuiltinContextSession(sessionId, contextDir);
+        if (!existing) {
+            throw new Error(`DeepCCC session not found: ${sessionId}`);
+        }
+        return { mode: "resumed", sessionId };
+    }
+    return {
+        mode: "new",
+        sessionId: newBuiltinSessionId(options.now, options.randomSuffix),
+    };
+}

package/dist/deepccc-agent/src/sigint.js

@@ -0,0 +1,26 @@
+export const CTRL_C_CONFIRM_WINDOW_MS = 2000;
+export function createCtrlCState(options = {}) {
+    const windowMs = options.windowMs ?? CTRL_C_CONFIRM_WINDOW_MS;
+    const now = options.now ?? Date.now;
+    let pending = null;
+    let lastPressAt = 0;
+    return {
+        press(isGenerating) {
+            const action = isGenerating ? "interrupt" : "exit";
+            const current = now();
+            const isConfirmed = pending === action && current - lastPressAt <= windowMs;
+            if (isConfirmed) {
+                pending = null;
+                lastPressAt = 0;
+                return action;
+            }
+            pending = action;
+            lastPressAt = current;
+            return isGenerating ? "arm-interrupt" : "arm-exit";
+        },
+        reset() {
+            pending = null;
+            lastPressAt = 0;
+        },
+    };
+}

package/dist/deepccc-agent/src/skills.js

@@ -0,0 +1,178 @@
+/**
+ * skills.ts — 多来源技能扫描（DeepCCC 统一入口）
+ *
+ * 并行扫描 Claude / Codex / Cursor / DeepCCC 四套目录式技能
+ * （<name>/SKILL.md + YAML frontmatter，三套生态同构）。
+ *
+ * 同名优先级（高 → 低）：deepccc > codex > cursor > claude；
+ * 同来源内：project（项目级）> global（用户级）。
+ * 目录列表按低 → 高排列，扫描时后者覆盖前者，天然实现优先级。
+ *
+ * 热加载：SKILL.md 内容带 mtime 缓存，文件变化时自动重读；
+ * 目录枚举每次都做（新技能目录立即被发现）。因此"创建技能 →
+ * 下一次对话自动生效"，无需重启，也无需常驻 watcher。
+ */
+import { readdirSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** 解析 SKILL.md frontmatter（兼容 CRLF），返回 name + description；无 frontmatter 返回 null */
+export function parseSkillFrontmatter(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(content);
+    if (!match)
+        return null;
+    const fm = match[1];
+    const nameMatch = /^name:\s*(.+?)\s*$/m.exec(fm);
+    if (!nameMatch)
+        return null;
+    const descMatch = /^description:\s*(.+?)\s*$/m.exec(fm);
+    return {
+        name: nameMatch[1].trim(),
+        description: descMatch?.[1].trim() ?? "",
+    };
+}
+// ---------------------------------------------------------------------------
+// mtime 热加载缓存：同一进程内重复扫描命中缓存（stat 校验），文件变化自动重读
+// ---------------------------------------------------------------------------
+const skillFileCache = new Map();
+async function readSkillFile(skillPath) {
+    let st;
+    try {
+        st = await stat(skillPath);
+    }
+    catch {
+        return null;
+    }
+    if (!st.isFile())
+        return null;
+    const cached = skillFileCache.get(skillPath);
+    if (cached && cached.mtimeMs === st.mtimeMs)
+        return cached.content;
+    const content = await readFile(skillPath, "utf8");
+    skillFileCache.set(skillPath, { mtimeMs: st.mtimeMs, content });
+    return content;
+}
+/**
+ * 扫描多个 skill 目录（并行读取），按 name 去重。
+ * 同名技能：后面的 spec（高优先级）覆盖前面的（低优先级）。
+ * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过；缺失目录跳过。
+ */
+export async function scanSkillsDirs(dirs) {
+    const byName = new Map();
+    for (const spec of dirs) {
+        let entries;
+        try {
+            entries = readdirSync(spec.dir, { withFileTypes: true });
+        }
+        catch {
+            continue; // 目录不存在或不可读：跳过
+        }
+        // 目录内所有候选 SKILL.md 并行读取（读文件是扫描的瓶颈）
+        const results = await Promise.all(entries
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map(async (entry) => {
+            const skillPath = join(spec.dir, entry.name, "SKILL.md");
+            const content = await readSkillFile(skillPath);
+            if (content === null)
+                return null;
+            const parsed = parseSkillFrontmatter(content);
+            if (!parsed)
+                return null;
+            return { ...parsed, skillPath };
+        }));
+        for (const result of results) {
+            if (!result)
+                continue;
+            byName.set(result.name, {
+                name: result.name,
+                description: result.description,
+                skillPath: result.skillPath,
+                source: spec.source,
+                scope: spec.scope,
+            });
+        }
+    }
+    return [...byName.values()];
+}
+/**
+ * 默认技能扫描目录（按优先级从低到高排列，扫描时后者覆盖前者）：
+ * claude(global→project) < cursor(global→project) < codex(global→project) < deepccc(global→project)
+ * 其中 codex 全局包含 ~/.codex/skills（CLI 旧路径）与 ~/.agents/skills（标准全局目录）。
+ */
+export function buildDefaultSkillDirs(cwd) {
+    const h = homedir();
+    return [
+        { dir: join(h, ".claude", "skills"), source: "claude", scope: "global" },
+        { dir: join(cwd, ".claude", "skills"), source: "claude", scope: "project" },
+        { dir: join(h, ".cursor", "skills"), source: "cursor", scope: "global" },
+        { dir: join(cwd, ".cursor", "skills"), source: "cursor", scope: "project" },
+        { dir: join(h, ".codex", "skills"), source: "codex", scope: "global" },
+        { dir: join(h, ".agents", "skills"), source: "codex", scope: "global" },
+        { dir: join(cwd, ".codex", "skills"), source: "codex", scope: "project" },
+        { dir: join(h, ".deepccc", "skills"), source: "deepccc", scope: "global" },
+        { dir: join(cwd, ".deepccc", "skills"), source: "deepccc", scope: "project" },
+    ];
+}
+/**
+ * 把技能绝对路径转成 prompt 展示形式：主目录下的路径缩写为 `~/...`（跨机器、
+ * 跨用户稳定，避免用户名/盘符差异导致 system 前缀变化破坏缓存命中）；
+ * 分隔符统一为 `/`。主目录外的路径保持绝对路径（仅统一分隔符）。
+ */
+export function normalizeSkillPathForPrompt(skillPath) {
+    const home = homedir().replace(/[\\/]+$/, "").replace(/\\/g, "/");
+    const normalized = skillPath.replace(/\\/g, "/");
+    if (normalized === home)
+        return "~";
+    if (normalized.startsWith(home + "/")) {
+        return "~" + normalized.slice(home.length);
+    }
+    return normalized;
+}
+/**
+ * 生成 skill 索引提示词（注入 system prompt）。
+ * 索引只含 name + description + 来源 + 路径，并指示模型在任务匹配时
+ * 先用 read_file 读取 SKILL.md 全文再执行；同时声明"创建技能"约定
+ * （模型在对话中应把新技能创建到 ~/.deepccc/skills 或项目 .deepccc/skills）。
+ * 路径经 normalizeSkillPathForPrompt 缩写，保持跨机器前缀稳定。
+ */
+export function buildSkillsIndexPrompt(skills) {
+    if (skills.length === 0)
+        return "";
+    const lines = [
+        "## 可用技能",
+        "技能会从 Claude/Codex/Cursor/DeepCCC 技能目录并行扫描。",
+        "名称冲突时：DeepCCC > Codex > Cursor > Claude 优先；同一来源内，项目级优先于全局。",
+        "当用户请求匹配某个技能的描述时，先用 read_file 读取其完整 SKILL.md，然后严格按其指令执行。",
+        "",
+        ...skills.map((s) => `- **${s.name}** [${s.source}:${s.scope}] (\`${normalizeSkillPathForPrompt(s.skillPath)}\`): ${s.description || "(无描述)"}`),
+        "",
+        "## 创建技能",
+        "当用户要求创建技能时，按 Codex 风格的目录技能创建：",
+        "~/.deepccc/skills/<name>/SKILL.md（全局，默认）或 <cwd>/.deepccc/skills/<name>/SKILL.md（项目级，仅当用户明确要求项目级技能时）。",
+        "SKILL.md 格式：",
+        "```",
+        "---",
+        "name: <skill-name>",
+        "description: <one-line description>",
+        "---",
+        "",
+        "<instructions>",
+        "```",
+        "新技能会在下一条消息自动生效（热加载）；无需重启。",
+    ];
+    return lines.join("\n");
+}
+/** 生成 Codex 结构的新技能 SKILL.md 模板（供 CLI skill create / 对话创建约定共用） */
+export function buildSkillTemplate(name, description) {
+    return [
+        "---",
+        `name: ${name}`,
+        `description: ${description}`,
+        "---",
+        "",
+        `# ${name}`,
+        "",
+        "<skill instructions>",
+        "",
+    ].join("\n");
+}

package/dist/deepccc-agent/src/web-tools.js

@@ -0,0 +1,246 @@
+/**
+ * web-tools.ts — websearch / webfetch 内置工具（agent 端联网，业界主流做法）
+ *
+ * 与 Claude Code 的 WebSearch/WebFetch、Codex 的 web search 相同形态：
+ * 模型通过 function calling 调用，agent 进程执行 HTTP 请求，结果回填上下文。
+ * 两者都是只读外部网络操作，不触碰本地文件系统，无需权限询问。
+ *
+ * - websearch：DuckDuckGo HTML 端点（免 API key），返回标题 + URL + 摘要
+ * - webfetch：HTTP GET + HTML 转纯文本，控制大小与超时
+ *
+ * 零新依赖：使用 Node 20 内置 fetch / AbortSignal / Buffer。
+ * 解析逻辑拆成纯函数导出，便于单测；fetch 可通过 options 注入 mock。
+ */
+export const WEB_SEARCH_TIMEOUT_MS = 15_000;
+export const WEB_FETCH_TIMEOUT_MS = 20_000;
+export const WEB_SEARCH_DEFAULT_RESULTS = 5;
+export const WEB_SEARCH_MAX_RESULTS = 10;
+export const WEB_FETCH_DEFAULT_CHARS = 10_000;
+export const WEB_FETCH_MAX_CHARS = 100_000;
+/** webfetch 读取响应体的大小上限（超出即截断），防止把整个大文件拉进上下文 */
+export const WEB_FETCH_MAX_BYTES = 512 * 1024;
+const SEARCH_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+function normalizeMaxResults(value) {
+    if (value === undefined)
+        return WEB_SEARCH_DEFAULT_RESULTS;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("maxResults must be a positive integer when provided");
+    }
+    return Math.min(value, WEB_SEARCH_MAX_RESULTS);
+}
+function normalizeMaxChars(value) {
+    if (value === undefined)
+        return WEB_FETCH_DEFAULT_CHARS;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("maxChars must be a positive integer when provided");
+    }
+    return Math.min(value, WEB_FETCH_MAX_CHARS);
+}
+function buildSignal(timeoutMs, abortSignal) {
+    const signals = [AbortSignal.timeout(timeoutMs)];
+    if (abortSignal)
+        signals.push(abortSignal);
+    return signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#0?39;/gi, "'")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&#(\d+);/g, (_, n) => {
+        try {
+            return String.fromCodePoint(Number(n));
+        }
+        catch {
+            return "";
+        }
+    })
+        .replace(/&#x([0-9a-f]+);/gi, (_, h) => {
+        try {
+            return String.fromCodePoint(parseInt(h, 16));
+        }
+        catch {
+            return "";
+        }
+    })
+        .replace(/&amp;/gi, "&");
+}
+function stripTags(s) {
+    return decodeEntities(s.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim());
+}
+/** 提取 <title> 文本（用于 webfetch 结果），无则返回空字符串 */
+export function extractHtmlTitle(html) {
+    const m = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    return m ? stripTags(m[1]) : "";
+}
+/**
+ * HTML 转纯文本：
+ * 去掉 script/style/noscript/svg/注释 → 块级元素补换行 → 去标签 → 解实体 → 压缩空白。
+ */
+export function htmlToPlainText(html) {
+    let text = html
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
+        .replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, " ")
+        .replace(/<svg\b[^>]*>[\s\S]*?<\/svg>/gi, " ")
+        .replace(/<!--[\s\S]*?-->/g, " ")
+        .replace(/<\/(p|div|li|tr|h[1-6]|pre|blockquote|section|article|table|ul|ol|header|footer|nav|dl|dd|dt)>/gi, "\n")
+        .replace(/<(br|hr)\s*\/?>/gi, "\n")
+        .replace(/<[^>]+>/g, "");
+    text = decodeEntities(text);
+    return text
+        .split("\n")
+        .map((line) => line.replace(/\s+/g, " ").trim())
+        .filter((line, i, arr) => line !== "" || (i > 0 && arr[i - 1] !== ""))
+        .join("\n")
+        .trim();
+}
+/** 解码 DuckDuckGo 结果链接：/l/?uddg=<encoded> 还原为目标 URL */
+export function decodeDdgHref(href) {
+    let h = href.trim();
+    if (h.startsWith("//"))
+        h = "https:" + h;
+    try {
+        const u = new URL(h);
+        if (u.hostname === "duckduckgo.com" && u.pathname.startsWith("/l/")) {
+            const uddg = u.searchParams.get("uddg");
+            if (uddg)
+                return decodeURIComponent(uddg);
+        }
+        return u.toString();
+    }
+    catch {
+        return h;
+    }
+}
+/**
+ * 解析 DuckDuckGo HTML 搜索结果页（html.duckduckgo.com/html）。
+ * 提取 result__a（标题 + href）与 result__snippet（摘要）。
+ */
+export function parseDuckDuckGoHtml(html) {
+    const results = [];
+    const titleRe = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+    const snippetRe = /<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+    const titleMatches = [...html.matchAll(titleRe)];
+    const snippetMatches = [...html.matchAll(snippetRe)];
+    titleMatches.forEach((m, i) => {
+        const title = stripTags(m[2]);
+        const url = decodeDdgHref(m[1]);
+        const snippet = snippetMatches[i] ? stripTags(snippetMatches[i][1]) : "";
+        if (!title && !url)
+            return;
+        results.push({ title, url, snippet });
+    });
+    return results;
+}
+/** 读取响应体并限制字节数（超出截断），避免整页大文件进入上下文 */
+async function readBodyWithLimit(res, maxBytes) {
+    if (!res.body) {
+        const text = await res.text();
+        return { text, truncated: Buffer.byteLength(text, "utf8") > maxBytes };
+    }
+    const reader = res.body.getReader();
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        if (total + value.byteLength > maxBytes) {
+            const remaining = maxBytes - total;
+            if (remaining > 0)
+                chunks.push(value.subarray(0, remaining));
+            truncated = true;
+            await reader.cancel().catch(() => { });
+            break;
+        }
+        chunks.push(value);
+        total += value.byteLength;
+    }
+    return { text: Buffer.concat(chunks.map((c) => Buffer.from(c))).toString("utf8"), truncated };
+}
+/**
+ * websearch：DuckDuckGo HTML 搜索（免 API key），返回标题 + URL + 摘要。
+ * 网络失败抛错（成为 tool-error），搜索无结果返回空数组（不是错误）。
+ */
+export async function webSearchForTool(input, options = {}) {
+    const query = input.query?.trim();
+    if (!query)
+        throw new Error("query is required");
+    const maxResults = normalizeMaxResults(input.maxResults);
+    const startedAt = Date.now();
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const res = await fetchImpl(url, {
+        headers: {
+            "User-Agent": SEARCH_UA,
+            Accept: "text/html,application/xhtml+xml",
+        },
+        redirect: "follow",
+        signal: buildSignal(options.timeoutMs ?? WEB_SEARCH_TIMEOUT_MS, options.abortSignal),
+    });
+    if (!res.ok) {
+        throw new Error(`web search failed: HTTP ${res.status} ${res.statusText}`);
+    }
+    const { text } = await readBodyWithLimit(res, WEB_FETCH_MAX_BYTES);
+    const all = parseDuckDuckGoHtml(text);
+    const results = all.slice(0, maxResults);
+    return {
+        query,
+        results,
+        truncated: all.length > results.length,
+        durationMs: Date.now() - startedAt,
+    };
+}
+/**
+ * webfetch：HTTP GET + HTML 转纯文本。
+ * 只允许 http/https（防 file:// 等本地协议），非 2xx 抛错。
+ */
+export async function webFetchForTool(input, options = {}) {
+    const raw = input.url?.trim();
+    if (!raw)
+        throw new Error("url is required");
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new Error(`invalid URL: ${raw}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`unsupported protocol: ${parsed.protocol} (only http/https allowed)`);
+    }
+    const maxChars = normalizeMaxChars(input.maxChars);
+    const startedAt = Date.now();
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const res = await fetchImpl(parsed.toString(), {
+        headers: {
+            "User-Agent": SEARCH_UA,
+            Accept: "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.8",
+        },
+        redirect: "follow",
+        signal: buildSignal(options.timeoutMs ?? WEB_FETCH_TIMEOUT_MS, options.abortSignal),
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText} for ${parsed.toString()}`);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    const { text: body, truncated: bodyTruncated } = await readBodyWithLimit(res, WEB_FETCH_MAX_BYTES);
+    const title = extractHtmlTitle(body);
+    const plain = htmlToPlainText(body);
+    const text = plain.length > maxChars ? plain.slice(0, maxChars) : plain;
+    return {
+        url: parsed.toString(),
+        contentType,
+        title,
+        text,
+        chars: text.length,
+        truncated: bodyTruncated || plain.length > maxChars,
+        durationMs: Date.now() - startedAt,
+    };
+}

package/dist/src/adapters/adapter-interface.js

@@ -0,0 +1,19 @@
+// =============================================================================
+// adapter-interface.ts — 统一的 AI 工具适配器接口和归一化消息类型
+// =============================================================================
+// 所有 AI 工具适配器（Claude SDK、Cursor CLI、Codex CLI 等）都必须实现
+// ToolAdapter 接口。归一化消息类型 UnifiedBlock 屏蔽了各工具的差异，
+// 使 session.ts 不需要关心底层是哪个 AI 工具。
+// =============================================================================
+/** 从 [User message]...[/User message] 包装中提取原始消息并识别 /plan /ask 前缀 */
+export function parseUserCommand(userText) {
+    const match = userText.match(/\[User message\]\n(.*?)\n\[\/User message\]/s);
+    if (!match)
+        return { original: "", mode: null };
+    const original = match[1].trimStart();
+    if (original.startsWith("/plan"))
+        return { original, mode: "plan" };
+    if (original.startsWith("/ask"))
+        return { original, mode: "ask" };
+    return { original, mode: null };
+}

package/dist/src/adapters/ccc-adapter.js

@@ -0,0 +1,112 @@
+import { ChatSession } from "../../deepccc-agent/src/index.js";
+import { config as deepCccConfig } from "../../deepccc-agent/src/config.js";
+import { getBuiltinContextSession, newBuiltinSessionId, normalizeBuiltinSessionId, } from "../../deepccc-agent/src/context.js";
+import { config, CCC_SESSION_PREFIX } from "../config.js";
+function toChatSessionOptions(sessionId, cwd, options) {
+    return {
+        cwd,
+        persist: true,
+        sessionId,
+        contextDir: options.contextDir,
+        compactAtTokens: options.compactAtTokens,
+        keepRecentMessages: options.keepRecentMessages,
+        compactionTimeoutMs: options.compactionTimeoutMs,
+        maxSteps: options.maxSteps,
+        // chatccc 无终端可交互，且对齐 claude/codex 适配器的 bypass 模式：
+        // 高危命令不询问，全部放行（与独立 deepccc CLI 的 ask 模式不同）
+        permissionMode: "bypass",
+    };
+}
+export function createCccAdapter(options = {}) {
+    if (!options.apiKey?.trim()) {
+        throw new Error("ChatCCC 未配置 CCC Agent API Key。请先填写 ccc.DEEPSEEK_API_KEY 后再启用 CCC Agent。");
+    }
+    const chatConfig = {
+        apiKey: options.apiKey,
+        ...(options.provider !== undefined ? { provider: options.provider } : {}),
+        ...(options.baseURL !== undefined ? { baseURL: options.baseURL } : {}),
+        ...(options.model !== undefined ? { model: options.model } : {}),
+        ...(options.effort !== undefined ? { effort: options.effort } : {}),
+    };
+    return {
+        displayName: "CCC Agent",
+        sessionDescPrefix: CCC_SESSION_PREFIX,
+        // Non-streaming DeepCCC emits its reply only after the provider request finishes,
+        // so unchanged output cannot distinguish a slow request from a stalled response.
+        responseStallDetectionEnabled: deepCccConfig.streaming,
+        async createSession(cwd) {
+            const sessionId = newBuiltinSessionId();
+            const session = new ChatSession(chatConfig, toChatSessionOptions(sessionId, cwd, options));
+            session.reset();
+            return { sessionId };
+        },
+        async *prompt(sessionId, userText, cwd, signal, _promptOptions) {
+            const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
+            const session = new ChatSession(chatConfig, toChatSessionOptions(normalizedSessionId, cwd, options));
+            for await (const event of session.chat(userText, signal)) {
+                if (event.type === "status") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{
+                                type: "agent_status",
+                                status: event.phase === "compacting" ? "compacting" : "responding",
+                            }],
+                    };
+                }
+                else if (event.type === "text") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{ type: "text", text: event.text }],
+                    };
+                }
+                else if (event.type === "tool_use") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{
+                                type: "tool_use",
+                                id: event.id,
+                                name: event.name,
+                                input: event.input,
+                            }],
+                    };
+                }
+                else if (event.type === "tool_result") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{
+                                type: "tool_result",
+                                tool_use_id: event.tool_use_id,
+                                content: event.content,
+                                is_error: event.is_error,
+                            }],
+                    };
+                }
+                else if (event.type === "done" && !signal?.aborted) {
+                    yield {
+                        type: "assistant",
+                        blocks: [],
+                        isFinalResponse: true,
+                    };
+                }
+                else if (event.type === "error") {
+                    throw new Error(event.message);
+                }
+            }
+        },
+        async getSessionInfo(sessionId) {
+            const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
+            const info = getBuiltinContextSession(normalizedSessionId, options.contextDir);
+            if (!info)
+                return undefined;
+            return {
+                sessionId: info.sessionId,
+                cwd: info.cwd,
+                lastModified: info.updatedAt,
+                model: options.model ?? config.ccc.model,
+            };
+        },
+        async closeSession(_sessionId) {
+            // ChatSession uses one request-scoped stream per prompt. AbortSignal handles cancellation.
+        },
+    };
+}