@poolzin/pool-bot 2026.3.27 → 2026.3.28

package/dist/agents/compaction.js

@@ -1,270 +0,0 @@
-import { estimateTokens, generateSummary } from "@mariozechner/pi-coding-agent";
-import { retryAsync } from "../infra/retry.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
-import { DEFAULT_CONTEXT_TOKENS } from "./defaults.js";
-import { repairToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
-const log = createSubsystemLogger("compaction");
-export const BASE_CHUNK_RATIO = 0.4;
-export const MIN_CHUNK_RATIO = 0.15;
-export const SAFETY_MARGIN = 1.2; // 20% buffer for estimateTokens() inaccuracy
-const DEFAULT_SUMMARY_FALLBACK = "No prior history.";
-const DEFAULT_PARTS = 2;
-const MERGE_SUMMARIES_INSTRUCTIONS = "Merge these partial summaries into a single cohesive summary. Preserve decisions," +
-    " TODOs, open questions, and any constraints.";
-export function estimateMessagesTokens(messages) {
-    // SECURITY: toolResult.details can contain untrusted/verbose payloads; never include in LLM-facing compaction.
-    const safe = stripToolResultDetails(messages);
-    return safe.reduce((sum, message) => sum + estimateTokens(message), 0);
-}
-function normalizeParts(parts, messageCount) {
-    if (!Number.isFinite(parts) || parts <= 1) {
-        return 1;
-    }
-    return Math.min(Math.max(1, Math.floor(parts)), Math.max(1, messageCount));
-}
-export function splitMessagesByTokenShare(messages, parts = DEFAULT_PARTS) {
-    if (messages.length === 0) {
-        return [];
-    }
-    const normalizedParts = normalizeParts(parts, messages.length);
-    if (normalizedParts <= 1) {
-        return [messages];
-    }
-    const totalTokens = estimateMessagesTokens(messages);
-    const targetTokens = totalTokens / normalizedParts;
-    const chunks = [];
-    let current = [];
-    let currentTokens = 0;
-    for (const message of messages) {
-        const messageTokens = estimateTokens(message);
-        if (chunks.length < normalizedParts - 1 &&
-            current.length > 0 &&
-            currentTokens + messageTokens > targetTokens) {
-            chunks.push(current);
-            current = [];
-            currentTokens = 0;
-        }
-        current.push(message);
-        currentTokens += messageTokens;
-    }
-    if (current.length > 0) {
-        chunks.push(current);
-    }
-    return chunks;
-}
-// Overhead reserved for summarization prompt, system prompt, previous summary,
-// and serialization wrappers (<conversation> tags, instructions, etc.).
-// generateSummary uses reasoning: "high" which also consumes context budget.
-export const SUMMARIZATION_OVERHEAD_TOKENS = 4096;
-export function chunkMessagesByMaxTokens(messages, maxTokens) {
-    if (messages.length === 0) {
-        return [];
-    }
-    // Apply safety margin to compensate for estimateTokens() underestimation
-    // (chars/4 heuristic misses multi-byte chars, special tokens, code tokens, etc.)
-    const effectiveMax = Math.max(1, Math.floor(maxTokens / SAFETY_MARGIN));
-    const chunks = [];
-    let currentChunk = [];
-    let currentTokens = 0;
-    for (const message of messages) {
-        const messageTokens = estimateTokens(message);
-        if (currentChunk.length > 0 && currentTokens + messageTokens > effectiveMax) {
-            chunks.push(currentChunk);
-            currentChunk = [];
-            currentTokens = 0;
-        }
-        currentChunk.push(message);
-        currentTokens += messageTokens;
-        if (messageTokens > effectiveMax) {
-            // Split oversized messages to avoid unbounded chunk growth.
-            chunks.push(currentChunk);
-            currentChunk = [];
-            currentTokens = 0;
-        }
-    }
-    if (currentChunk.length > 0) {
-        chunks.push(currentChunk);
-    }
-    return chunks;
-}
-/**
- * Compute adaptive chunk ratio based on average message size.
- * When messages are large, we use smaller chunks to avoid exceeding model limits.
- */
-export function computeAdaptiveChunkRatio(messages, contextWindow) {
-    if (messages.length === 0) {
-        return BASE_CHUNK_RATIO;
-    }
-    const totalTokens = estimateMessagesTokens(messages);
-    const avgTokens = totalTokens / messages.length;
-    // Apply safety margin to account for estimation inaccuracy
-    const safeAvgTokens = avgTokens * SAFETY_MARGIN;
-    const avgRatio = safeAvgTokens / contextWindow;
-    // If average message is > 10% of context, reduce chunk ratio
-    if (avgRatio > 0.1) {
-        const reduction = Math.min(avgRatio * 2, BASE_CHUNK_RATIO - MIN_CHUNK_RATIO);
-        return Math.max(MIN_CHUNK_RATIO, BASE_CHUNK_RATIO - reduction);
-    }
-    return BASE_CHUNK_RATIO;
-}
-/**
- * Check if a single message is too large to summarize.
- * If single message > 50% of context, it can't be summarized safely.
- */
-export function isOversizedForSummary(msg, contextWindow) {
-    const tokens = estimateTokens(msg) * SAFETY_MARGIN;
-    return tokens > contextWindow * 0.5;
-}
-async function summarizeChunks(params) {
-    if (params.messages.length === 0) {
-        return params.previousSummary ?? DEFAULT_SUMMARY_FALLBACK;
-    }
-    // SECURITY: never feed toolResult.details into summarization prompts.
-    const safeMessages = stripToolResultDetails(params.messages);
-    const chunks = chunkMessagesByMaxTokens(safeMessages, params.maxChunkTokens);
-    let summary = params.previousSummary;
-    for (const chunk of chunks) {
-        summary = await retryAsync(() => generateSummary(chunk, params.model, params.reserveTokens, params.apiKey, params.signal, params.customInstructions, summary), {
-            attempts: 3,
-            minDelayMs: 500,
-            maxDelayMs: 5000,
-            jitter: 0.2,
-            label: "compaction/generateSummary",
-            shouldRetry: (err) => !(err instanceof Error && err.name === "AbortError"),
-        });
-    }
-    return summary ?? DEFAULT_SUMMARY_FALLBACK;
-}
-/**
- * Summarize with progressive fallback for handling oversized messages.
- * If full summarization fails, tries partial summarization excluding oversized messages.
- */
-export async function summarizeWithFallback(params) {
-    const { messages, contextWindow } = params;
-    if (messages.length === 0) {
-        return params.previousSummary ?? DEFAULT_SUMMARY_FALLBACK;
-    }
-    // Try full summarization first
-    try {
-        return await summarizeChunks(params);
-    }
-    catch (fullError) {
-        log.warn(`Full summarization failed, trying partial: ${fullError instanceof Error ? fullError.message : String(fullError)}`);
-    }
-    // Fallback 1: Summarize only small messages, note oversized ones
-    const smallMessages = [];
-    const oversizedNotes = [];
-    for (const msg of messages) {
-        if (isOversizedForSummary(msg, contextWindow)) {
-            const role = msg.role ?? "message";
-            const tokens = estimateTokens(msg);
-            oversizedNotes.push(`[Large ${role} (~${Math.round(tokens / 1000)}K tokens) omitted from summary]`);
-        }
-        else {
-            smallMessages.push(msg);
-        }
-    }
-    if (smallMessages.length > 0) {
-        try {
-            const partialSummary = await summarizeChunks({
-                ...params,
-                messages: smallMessages,
-            });
-            const notes = oversizedNotes.length > 0 ? `\n\n${oversizedNotes.join("\n")}` : "";
-            return partialSummary + notes;
-        }
-        catch (partialError) {
-            log.warn(`Partial summarization also failed: ${partialError instanceof Error ? partialError.message : String(partialError)}`);
-        }
-    }
-    // Final fallback: Just note what was there
-    return (`Context contained ${messages.length} messages (${oversizedNotes.length} oversized). ` +
-        `Summary unavailable due to size limits.`);
-}
-export async function summarizeInStages(params) {
-    const { messages } = params;
-    if (messages.length === 0) {
-        return params.previousSummary ?? DEFAULT_SUMMARY_FALLBACK;
-    }
-    const minMessagesForSplit = Math.max(2, params.minMessagesForSplit ?? 4);
-    const parts = normalizeParts(params.parts ?? DEFAULT_PARTS, messages.length);
-    const totalTokens = estimateMessagesTokens(messages);
-    if (parts <= 1 || messages.length < minMessagesForSplit || totalTokens <= params.maxChunkTokens) {
-        return summarizeWithFallback(params);
-    }
-    const splits = splitMessagesByTokenShare(messages, parts).filter((chunk) => chunk.length > 0);
-    if (splits.length <= 1) {
-        return summarizeWithFallback(params);
-    }
-    const partialSummaries = [];
-    for (const chunk of splits) {
-        partialSummaries.push(await summarizeWithFallback({
-            ...params,
-            messages: chunk,
-            previousSummary: undefined,
-        }));
-    }
-    if (partialSummaries.length === 1) {
-        return partialSummaries[0];
-    }
-    const summaryMessages = partialSummaries.map((summary) => ({
-        role: "user",
-        content: summary,
-        timestamp: Date.now(),
-    }));
-    const mergeInstructions = params.customInstructions
-        ? `${MERGE_SUMMARIES_INSTRUCTIONS}\n\nAdditional focus:\n${params.customInstructions}`
-        : MERGE_SUMMARIES_INSTRUCTIONS;
-    return summarizeWithFallback({
-        ...params,
-        messages: summaryMessages,
-        customInstructions: mergeInstructions,
-    });
-}
-export function pruneHistoryForContextShare(params) {
-    const maxHistoryShare = params.maxHistoryShare ?? 0.5;
-    const budgetTokens = Math.max(1, Math.floor(params.maxContextTokens * maxHistoryShare));
-    let keptMessages = params.messages;
-    const allDroppedMessages = [];
-    let droppedChunks = 0;
-    let droppedMessages = 0;
-    let droppedTokens = 0;
-    const parts = normalizeParts(params.parts ?? DEFAULT_PARTS, keptMessages.length);
-    while (keptMessages.length > 0 && estimateMessagesTokens(keptMessages) > budgetTokens) {
-        const chunks = splitMessagesByTokenShare(keptMessages, parts);
-        if (chunks.length <= 1) {
-            break;
-        }
-        const [dropped, ...rest] = chunks;
-        const flatRest = rest.flat();
-        // After dropping a chunk, repair tool_use/tool_result pairing to handle
-        // orphaned tool_results (whose tool_use was in the dropped chunk).
-        // repairToolUseResultPairing drops orphaned tool_results, preventing
-        // "unexpected tool_use_id" errors from Anthropic's API.
-        const repairReport = repairToolUseResultPairing(flatRest);
-        const repairedKept = repairReport.messages;
-        // Track orphaned tool_results as dropped (they were in kept but their tool_use was dropped)
-        const orphanedCount = repairReport.droppedOrphanCount;
-        droppedChunks += 1;
-        droppedMessages += dropped.length + orphanedCount;
-        droppedTokens += estimateMessagesTokens(dropped);
-        // Note: We don't have the actual orphaned messages to add to droppedMessagesList
-        // since repairToolUseResultPairing doesn't return them. This is acceptable since
-        // the dropped messages are used for summarization, and orphaned tool_results
-        // without their tool_use context aren't useful for summarization anyway.
-        allDroppedMessages.push(...dropped);
-        keptMessages = repairedKept;
-    }
-    return {
-        messages: keptMessages,
-        droppedMessagesList: allDroppedMessages,
-        droppedChunks,
-        droppedMessages,
-        droppedTokens,
-        keptTokens: estimateMessagesTokens(keptMessages),
-        budgetTokens,
-    };
-}
-export function resolveContextWindowTokens(model) {
-    return Math.max(1, Math.floor(model?.contextWindow ?? DEFAULT_CONTEXT_TOKENS));
-}

package/dist/agents/content-blocks.js

@@ -1,16 +0,0 @@
-export function collectTextContentBlocks(content) {
-    if (!Array.isArray(content)) {
-        return [];
-    }
-    const parts = [];
-    for (const block of content) {
-        if (!block || typeof block !== "object") {
-            continue;
-        }
-        const rec = block;
-        if (rec.type === "text" && typeof rec.text === "string") {
-            parts.push(rec.text);
-        }
-    }
-    return parts;
-}

package/dist/agents/context-window-guard.js

@@ -1,40 +0,0 @@
-export const CONTEXT_WINDOW_HARD_MIN_TOKENS = 16_000;
-export const CONTEXT_WINDOW_WARN_BELOW_TOKENS = 32_000;
-function normalizePositiveInt(value) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return null;
-    }
-    const int = Math.floor(value);
-    return int > 0 ? int : null;
-}
-export function resolveContextWindowInfo(params) {
-    const fromModelsConfig = (() => {
-        const providers = params.cfg?.models?.providers;
-        const providerEntry = providers?.[params.provider];
-        const models = Array.isArray(providerEntry?.models) ? providerEntry.models : [];
-        const match = models.find((m) => m?.id === params.modelId);
-        return normalizePositiveInt(match?.contextWindow);
-    })();
-    const fromModel = normalizePositiveInt(params.modelContextWindow);
-    const baseInfo = fromModelsConfig
-        ? { tokens: fromModelsConfig, source: "modelsConfig" }
-        : fromModel
-            ? { tokens: fromModel, source: "model" }
-            : { tokens: Math.floor(params.defaultTokens), source: "default" };
-    const capTokens = normalizePositiveInt(params.cfg?.agents?.defaults?.contextTokens);
-    if (capTokens && capTokens < baseInfo.tokens) {
-        return { tokens: capTokens, source: "agentContextTokens" };
-    }
-    return baseInfo;
-}
-export function evaluateContextWindowGuard(params) {
-    const warnBelow = Math.max(1, Math.floor(params.warnBelowTokens ?? CONTEXT_WINDOW_WARN_BELOW_TOKENS));
-    const hardMin = Math.max(1, Math.floor(params.hardMinTokens ?? CONTEXT_WINDOW_HARD_MIN_TOKENS));
-    const tokens = Math.max(0, Math.floor(params.info.tokens));
-    return {
-        ...params.info,
-        tokens,
-        shouldWarn: tokens > 0 && tokens < warnBelow,
-        shouldBlock: tokens > 0 && tokens < hardMin,
-    };
-}

package/dist/agents/context.js

@@ -1,34 +0,0 @@
-// Lazy-load pi-coding-agent model metadata so we can infer context windows when
-// the agent reports a model id. This includes custom models.json entries.
-import { loadConfig } from "../config/config.js";
-import { resolvePoolbotAgentDir } from "./agent-paths.js";
-import { ensurePoolbotModelsJson } from "./models-config.js";
-const MODEL_CACHE = new Map();
-const loadPromise = (async () => {
-    try {
-        const { discoverAuthStorage, discoverModels } = await import("./pi-model-discovery.js");
-        const cfg = loadConfig();
-        await ensurePoolbotModelsJson(cfg);
-        const agentDir = resolvePoolbotAgentDir();
-        const authStorage = discoverAuthStorage(agentDir);
-        const modelRegistry = discoverModels(authStorage, agentDir);
-        const models = modelRegistry.getAll();
-        for (const m of models) {
-            if (!m?.id)
-                continue;
-            if (typeof m.contextWindow === "number" && m.contextWindow > 0) {
-                MODEL_CACHE.set(m.id, m.contextWindow);
-            }
-        }
-    }
-    catch {
-        // If pi-ai isn't available, leave cache empty; lookup will fall back.
-    }
-})();
-export function lookupContextTokens(modelId) {
-    if (!modelId)
-        return undefined;
-    // Best-effort: kick off loading, but don't block.
-    void loadPromise;
-    return MODEL_CACHE.get(modelId);
-}

package/dist/agents/current-time.js

@@ -1,16 +0,0 @@
-import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone, } from "./date-time.js";
-export function resolveCronStyleNow(cfg, nowMs) {
-    const userTimezone = resolveUserTimezone(cfg.agents?.defaults?.userTimezone);
-    const userTimeFormat = resolveUserTimeFormat(cfg.agents?.defaults?.timeFormat);
-    const formattedTime = formatUserTime(new Date(nowMs), userTimezone, userTimeFormat) ?? new Date(nowMs).toISOString();
-    const timeLine = `Current time: ${formattedTime} (${userTimezone})`;
-    return { userTimezone, formattedTime, timeLine };
-}
-export function appendCronStyleCurrentTimeLine(text, cfg, nowMs) {
-    const base = text.trimEnd();
-    if (!base || base.includes("Current time:")) {
-        return base;
-    }
-    const { timeLine } = resolveCronStyleNow(cfg, nowMs);
-    return `${base}\n${timeLine}`;
-}

package/dist/agents/date-time.js

@@ -1,158 +0,0 @@
-import { execSync } from "node:child_process";
-let cachedTimeFormat;
-export function resolveUserTimezone(configured) {
-    const trimmed = configured?.trim();
-    if (trimmed) {
-        try {
-            new Intl.DateTimeFormat("en-US", { timeZone: trimmed }).format(new Date());
-            return trimmed;
-        }
-        catch {
-            // ignore invalid timezone
-        }
-    }
-    const host = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    return host?.trim() || "UTC";
-}
-export function resolveUserTimeFormat(preference) {
-    if (preference === "12" || preference === "24")
-        return preference;
-    if (cachedTimeFormat)
-        return cachedTimeFormat;
-    cachedTimeFormat = detectSystemTimeFormat() ? "24" : "12";
-    return cachedTimeFormat;
-}
-export function normalizeTimestamp(raw) {
-    if (raw == null)
-        return undefined;
-    let timestampMs;
-    if (raw instanceof Date) {
-        timestampMs = raw.getTime();
-    }
-    else if (typeof raw === "number" && Number.isFinite(raw)) {
-        timestampMs = raw < 1_000_000_000_000 ? Math.round(raw * 1000) : Math.round(raw);
-    }
-    else if (typeof raw === "string") {
-        const trimmed = raw.trim();
-        if (!trimmed)
-            return undefined;
-        if (/^\d+(\.\d+)?$/.test(trimmed)) {
-            const num = Number(trimmed);
-            if (Number.isFinite(num)) {
-                if (trimmed.includes(".")) {
-                    timestampMs = Math.round(num * 1000);
-                }
-                else if (trimmed.length >= 13) {
-                    timestampMs = Math.round(num);
-                }
-                else {
-                    timestampMs = Math.round(num * 1000);
-                }
-            }
-        }
-        else {
-            const parsed = Date.parse(trimmed);
-            if (!Number.isNaN(parsed))
-                timestampMs = parsed;
-        }
-    }
-    if (timestampMs === undefined || !Number.isFinite(timestampMs))
-        return undefined;
-    return { timestampMs, timestampUtc: new Date(timestampMs).toISOString() };
-}
-export function withNormalizedTimestamp(value, rawTimestamp) {
-    const normalized = normalizeTimestamp(rawTimestamp);
-    if (!normalized)
-        return value;
-    return {
-        ...value,
-        timestampMs: typeof value.timestampMs === "number" && Number.isFinite(value.timestampMs)
-            ? value.timestampMs
-            : normalized.timestampMs,
-        timestampUtc: typeof value.timestampUtc === "string" && value.timestampUtc.trim()
-            ? value.timestampUtc
-            : normalized.timestampUtc,
-    };
-}
-function detectSystemTimeFormat() {
-    if (process.platform === "darwin") {
-        try {
-            const result = execSync("defaults read -g AppleICUForce24HourTime 2>/dev/null", {
-                encoding: "utf8",
-                timeout: 500,
-            }).trim();
-            if (result === "1")
-                return true;
-            if (result === "0")
-                return false;
-        }
-        catch {
-            // Not set, fall through
-        }
-    }
-    if (process.platform === "win32") {
-        try {
-            const result = execSync('powershell -Command "(Get-Culture).DateTimeFormat.ShortTimePattern"', { encoding: "utf8", timeout: 1000 }).trim();
-            if (result.startsWith("H"))
-                return true;
-            if (result.startsWith("h"))
-                return false;
-        }
-        catch {
-            // Fall through
-        }
-    }
-    try {
-        const sample = new Date(2000, 0, 1, 13, 0);
-        const formatted = new Intl.DateTimeFormat(undefined, { hour: "numeric" }).format(sample);
-        return formatted.includes("13");
-    }
-    catch {
-        return false;
-    }
-}
-function ordinalSuffix(day) {
-    if (day >= 11 && day <= 13)
-        return "th";
-    switch (day % 10) {
-        case 1:
-            return "st";
-        case 2:
-            return "nd";
-        case 3:
-            return "rd";
-        default:
-            return "th";
-    }
-}
-export function formatUserTime(date, timeZone, format) {
-    const use24Hour = format === "24";
-    try {
-        const parts = new Intl.DateTimeFormat("en-US", {
-            timeZone,
-            weekday: "long",
-            year: "numeric",
-            month: "long",
-            day: "numeric",
-            hour: use24Hour ? "2-digit" : "numeric",
-            minute: "2-digit",
-            hourCycle: use24Hour ? "h23" : "h12",
-        }).formatToParts(date);
-        const map = {};
-        for (const part of parts) {
-            if (part.type !== "literal")
-                map[part.type] = part.value;
-        }
-        if (!map.weekday || !map.year || !map.month || !map.day || !map.hour || !map.minute)
-            return undefined;
-        const dayNum = parseInt(map.day, 10);
-        const suffix = ordinalSuffix(dayNum);
-        const timePart = use24Hour
-            ? `${map.hour}:${map.minute}`
-            : `${map.hour}:${map.minute} ${map.dayPeriod ?? ""}`.trim();
-        return `${map.weekday}, ${map.month} ${dayNum}${suffix}, ${map.year} — ${timePart}`;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/agents/defaults.js

@@ -1,6 +0,0 @@
-// Defaults for agent metadata when upstream does not supply them.
-// Model id uses pi-ai's built-in Anthropic catalog.
-export const DEFAULT_PROVIDER = "anthropic";
-export const DEFAULT_MODEL = "claude-opus-4-5";
-// Context window: Opus 4.5 supports ~200k tokens (per pi-ai models.generated.ts).
-export const DEFAULT_CONTEXT_TOKENS = 200_000;

package/dist/agents/docs-path.js

@@ -1,20 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { resolvePoolBotPackageRoot } from "../infra/poolbot-root.js";
-export async function resolvePoolbotDocsPath(params) {
-    const workspaceDir = params.workspaceDir?.trim();
-    if (workspaceDir) {
-        const workspaceDocs = path.join(workspaceDir, "docs");
-        if (fs.existsSync(workspaceDocs))
-            return workspaceDocs;
-    }
-    const packageRoot = await resolvePoolBotPackageRoot({
-        cwd: params.cwd,
-        argv1: params.argv1,
-        moduleUrl: params.moduleUrl,
-    });
-    if (!packageRoot)
-        return null;
-    const packageDocs = path.join(packageRoot, "docs");
-    return fs.existsSync(packageDocs) ? packageDocs : null;
-}

package/dist/agents/doubao-models.js

@@ -1,121 +0,0 @@
-export const DOUBAO_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
-export const DOUBAO_CODING_BASE_URL = "https://ark.cn-beijing.volces.com/api/coding/v3";
-export const DOUBAO_DEFAULT_MODEL_ID = "doubao-seed-1-8-251228";
-export const DOUBAO_CODING_DEFAULT_MODEL_ID = "ark-code-latest";
-export const DOUBAO_DEFAULT_MODEL_REF = `volcengine/${DOUBAO_DEFAULT_MODEL_ID}`;
-// Volcano Engine Doubao pricing (approximate, adjust based on actual pricing)
-export const DOUBAO_DEFAULT_COST = {
-    input: 0.0001, // ¥0.0001 per 1K tokens
-    output: 0.0002, // ¥0.0002 per 1K tokens
-    cacheRead: 0,
-    cacheWrite: 0,
-};
-/**
- * Complete catalog of Volcano Engine models.
- *
- * Volcano Engine provides access to models
- * through the API. Authentication requires a Volcano Engine API Key.
- */
-export const DOUBAO_MODEL_CATALOG = [
-    {
-        id: "doubao-seed-code-preview-251028",
-        name: "doubao-seed-code-preview-251028",
-        reasoning: false,
-        input: ["text", "image"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "doubao-seed-1-8-251228",
-        name: "Doubao Seed 1.8",
-        reasoning: false,
-        input: ["text", "image"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "kimi-k2-5-260127",
-        name: "Kimi K2.5",
-        reasoning: false,
-        input: ["text", "image"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "glm-4-7-251222",
-        name: "GLM 4.7",
-        reasoning: false,
-        input: ["text", "image"],
-        contextWindow: 200000,
-        maxTokens: 4096,
-    },
-    {
-        id: "deepseek-v3-2-251201",
-        name: "DeepSeek V3.2",
-        reasoning: false,
-        input: ["text", "image"],
-        contextWindow: 128000,
-        maxTokens: 4096,
-    },
-];
-export function buildDoubaoModelDefinition(entry) {
-    return {
-        id: entry.id,
-        name: entry.name,
-        reasoning: entry.reasoning,
-        input: [...entry.input],
-        cost: DOUBAO_DEFAULT_COST,
-        contextWindow: entry.contextWindow,
-        maxTokens: entry.maxTokens,
-    };
-}
-export const DOUBAO_CODING_MODEL_CATALOG = [
-    {
-        id: "ark-code-latest",
-        name: "Ark Coding Plan",
-        reasoning: false,
-        input: ["text"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "doubao-seed-code",
-        name: "Doubao Seed Code",
-        reasoning: false,
-        input: ["text"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "glm-4.7",
-        name: "GLM 4.7 Coding",
-        reasoning: false,
-        input: ["text"],
-        contextWindow: 200000,
-        maxTokens: 4096,
-    },
-    {
-        id: "kimi-k2-thinking",
-        name: "Kimi K2 Thinking",
-        reasoning: false,
-        input: ["text"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "kimi-k2.5",
-        name: "Kimi K2.5 Coding",
-        reasoning: false,
-        input: ["text"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-    {
-        id: "doubao-seed-code-preview-251028",
-        name: "Doubao Seed Code Preview",
-        reasoning: false,
-        input: ["text"],
-        contextWindow: 256000,
-        maxTokens: 4096,
-    },
-];