open-multi-agent-kit 0.78.0

package/dist/providers/context-preflight.d.ts

@@ -0,0 +1,47 @@
+export interface ContextPreflightOptions {
+    provider: string;
+    model?: string;
+    contextWindow?: number;
+    reservedOutputTokens?: number;
+    safetyMarginTokens?: number;
+    runId?: string;
+    nodeId?: string;
+    projectRoot?: string;
+}
+export interface ContextPreflightReport {
+    provider: string;
+    model?: string;
+    contextWindow?: number;
+    reservedOutputTokens: number;
+    safetyMarginTokens: number;
+    maxInputTokens: number | null;
+    inputTokensEstimated: number;
+    inputTokensAfterCompaction: number;
+    originalChars: number;
+    finalChars: number;
+    compacted: boolean;
+    ok: boolean;
+    reason?: string;
+    runId?: string;
+    nodeId?: string;
+    projectRoot?: string;
+}
+export interface InputPreflightResult {
+    ok: boolean;
+    input: string;
+    report: ContextPreflightReport;
+}
+export interface PreflightMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface MessagesPreflightResult {
+    ok: boolean;
+    messages: PreflightMessage[];
+    report: ContextPreflightReport;
+}
+export declare function compactContext(input: string, options: ContextPreflightOptions): Promise<InputPreflightResult>;
+export declare function estimateInputTokens(text: string): number;
+export declare function preflightProviderInput(input: string, options: ContextPreflightOptions): Promise<InputPreflightResult>;
+export declare function preflightProviderMessages(messages: readonly PreflightMessage[], options: ContextPreflightOptions): Promise<MessagesPreflightResult>;
+export declare function contextPreflightErrorMessage(report: ContextPreflightReport): string;

package/dist/providers/context-preflight.js

@@ -0,0 +1,134 @@
+const DEFAULT_RESERVED_OUTPUT_TOKENS = 4096;
+const DEFAULT_SAFETY_MARGIN_TOKENS = 1024;
+const MIN_INPUT_TOKENS = 64;
+const CHARS_PER_TOKEN = 4;
+export async function compactContext(input, options) {
+    return preflightProviderInput(input, options);
+}
+export function estimateInputTokens(text) {
+    return estimateTokens(text);
+}
+export async function preflightProviderInput(input, options) {
+    const normalizedInput = String(input ?? "");
+    const compacted = compactTextToBudget(normalizedInput, resolveInputBudget(options));
+    return {
+        ok: compacted.ok,
+        input: compacted.text,
+        report: buildReport(options, normalizedInput, compacted.text, compacted.ok, compacted.reason),
+    };
+}
+export async function preflightProviderMessages(messages, options) {
+    const normalizedMessages = messages.map((message) => ({
+        role: message.role,
+        content: String(message.content ?? ""),
+    }));
+    const budget = resolveInputBudget(options);
+    const estimates = normalizedMessages.map((message) => estimateTokens(message.content));
+    let totalTokens = estimates.reduce((sum, value) => sum + value, 0);
+    if (budget == null || totalTokens <= budget) {
+        return {
+            ok: true,
+            messages: normalizedMessages,
+            report: buildReport(options, joinMessages(normalizedMessages), joinMessages(normalizedMessages), true, undefined),
+        };
+    }
+    const nextMessages = normalizedMessages.map((message) => ({ ...message }));
+    for (let index = nextMessages.length - 1; index >= 0 && totalTokens > budget; index -= 1) {
+        const current = nextMessages[index];
+        const otherTokens = totalTokens - estimates[index];
+        const allowedTokens = Math.max(MIN_INPUT_TOKENS, budget - otherTokens);
+        if (allowedTokens >= estimates[index])
+            continue;
+        const compacted = compactTextToBudget(current.content, allowedTokens);
+        nextMessages[index] = { ...current, content: compacted.text };
+        estimates[index] = estimateTokens(compacted.text);
+        totalTokens = otherTokens + estimates[index];
+    }
+    const finalText = joinMessages(nextMessages);
+    const ok = budget == null ? true : estimateTokens(finalText) <= budget;
+    return {
+        ok,
+        messages: nextMessages,
+        report: buildReport(options, joinMessages(normalizedMessages), finalText, ok, ok ? undefined : `Estimated input tokens exceed budget (${estimateTokens(finalText)} > ${budget})`),
+    };
+}
+export function contextPreflightErrorMessage(report) {
+    const budget = report.maxInputTokens == null ? "unknown" : String(report.maxInputTokens);
+    const lines = [
+        `[omk] ${report.provider} context preflight blocked this request.`,
+        `  model: ${report.model ?? "auto"}`,
+        `  estimated input tokens: ${report.inputTokensEstimated}`,
+        `  budget: ${budget}`,
+    ];
+    if (report.reason)
+        lines.push(`  reason: ${report.reason}`);
+    if (report.contextWindow != null)
+        lines.push(`  context window: ${report.contextWindow}`);
+    lines.push(`  reserved output tokens: ${report.reservedOutputTokens}`);
+    lines.push(`  safety margin tokens: ${report.safetyMarginTokens}`);
+    return lines.join("\n");
+}
+function resolveInputBudget(options) {
+    if (!Number.isFinite(options.contextWindow) || options.contextWindow == null || options.contextWindow <= 0) {
+        return null;
+    }
+    const reservedOutputTokens = options.reservedOutputTokens ?? DEFAULT_RESERVED_OUTPUT_TOKENS;
+    const safetyMarginTokens = options.safetyMarginTokens ?? DEFAULT_SAFETY_MARGIN_TOKENS;
+    return Math.max(MIN_INPUT_TOKENS, options.contextWindow - reservedOutputTokens - safetyMarginTokens);
+}
+function buildReport(options, originalText, finalText, ok, reason) {
+    const reservedOutputTokens = options.reservedOutputTokens ?? DEFAULT_RESERVED_OUTPUT_TOKENS;
+    const safetyMarginTokens = options.safetyMarginTokens ?? DEFAULT_SAFETY_MARGIN_TOKENS;
+    return {
+        provider: options.provider,
+        model: options.model,
+        contextWindow: options.contextWindow,
+        reservedOutputTokens,
+        safetyMarginTokens,
+        maxInputTokens: resolveInputBudget(options),
+        inputTokensEstimated: estimateTokens(originalText),
+        inputTokensAfterCompaction: estimateTokens(finalText),
+        originalChars: originalText.length,
+        finalChars: finalText.length,
+        compacted: originalText !== finalText,
+        ok,
+        reason,
+        runId: options.runId,
+        nodeId: options.nodeId,
+        projectRoot: options.projectRoot,
+    };
+}
+function compactTextToBudget(text, budget) {
+    if (budget == null || estimateTokens(text) <= budget) {
+        return { ok: true, text };
+    }
+    const maxChars = Math.max(MIN_INPUT_TOKENS * CHARS_PER_TOKEN, budget * CHARS_PER_TOKEN);
+    const compacted = compactText(text, maxChars);
+    if (estimateTokens(compacted) <= budget) {
+        return { ok: true, text: compacted };
+    }
+    return {
+        ok: false,
+        text: compacted,
+        reason: `Estimated input tokens exceed budget (${estimateTokens(compacted)} > ${budget})`,
+    };
+}
+function compactText(text, maxChars) {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    const headChars = Math.max(80, Math.floor(maxChars * 0.7));
+    const tailChars = Math.max(40, Math.floor(maxChars * 0.2));
+    const omitted = Math.max(0, trimmed.length - headChars - tailChars);
+    const marker = `\n\n[truncated: ${omitted} chars omitted]\n\n`;
+    const budgetForBody = Math.max(0, maxChars - marker.length);
+    const safeHead = Math.max(40, Math.floor(budgetForBody * 0.7));
+    const safeTail = Math.max(20, budgetForBody - safeHead);
+    return `${trimmed.slice(0, safeHead)}${marker}${trimmed.slice(-safeTail)}`;
+}
+function estimateTokens(text) {
+    return Math.max(1, Math.ceil(String(text ?? "").length / CHARS_PER_TOKEN));
+}
+function joinMessages(messages) {
+    return messages.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+}

package/dist/providers/deepseek/deepseek-balance.d.ts

@@ -0,0 +1,29 @@
+export interface DeepSeekBalanceInfo {
+    currency: "CNY" | "USD" | string;
+    total_balance: string;
+    granted_balance: string;
+    topped_up_balance: string;
+}
+export interface DeepSeekBalanceResponse {
+    is_available: boolean;
+    balance_infos: DeepSeekBalanceInfo[];
+}
+export interface DeepSeekAvailabilityCheck {
+    provider: "deepseek";
+    available: boolean;
+    checkedAt: number;
+    reason?: string;
+    disableForRun: boolean;
+    balance?: DeepSeekBalanceResponse;
+}
+export interface CheckDeepSeekBalanceOptions {
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+}
+export declare function checkDeepSeekBalance(options?: CheckDeepSeekBalanceOptions): Promise<DeepSeekAvailabilityCheck>;
+export declare function deepseekStatusReason(status: number): string;

package/dist/providers/deepseek/deepseek-balance.js

@@ -0,0 +1,80 @@
+export async function checkDeepSeekBalance(options = {}) {
+    const checkedAt = Date.now();
+    const env = options.env ?? process.env;
+    const apiKeyEnv = options.apiKeyEnv ?? "DEEPSEEK_API_KEY";
+    const apiKey = options.apiKey ?? env[apiKeyEnv];
+    if (!apiKey) {
+        return unavailable(checkedAt, `${apiKeyEnv} is not set`, true);
+    }
+    const baseUrl = (options.baseUrl ?? "https://api.deepseek.com").replace(/\/+$/, "");
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 10_000);
+    timeout.unref?.();
+    const signal = options.signal
+        ? AbortSignal.any([options.signal, controller.signal])
+        : controller.signal;
+    try {
+        const response = await fetchImpl(`${baseUrl}/user/balance`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                Accept: "application/json",
+            },
+            signal,
+        });
+        if (!response.ok) {
+            const reason = deepseekStatusReason(response.status);
+            return unavailable(checkedAt, reason, true);
+        }
+        const payload = await response.json();
+        const balance = {
+            is_available: Boolean(payload.is_available),
+            balance_infos: Array.isArray(payload.balance_infos) ? payload.balance_infos : [],
+        };
+        return {
+            provider: "deepseek",
+            available: balance.is_available,
+            checkedAt,
+            reason: balance.is_available ? undefined : "DeepSeek balance is unavailable for API calls",
+            disableForRun: !balance.is_available,
+            balance,
+        };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return unavailable(checkedAt, `DeepSeek balance preflight failed: ${reason}`, true);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function deepseekStatusReason(status) {
+    switch (status) {
+        case 400:
+            return "DeepSeek invalid request format";
+        case 401:
+            return "DeepSeek authentication failed";
+        case 402:
+            return "DeepSeek 402 insufficient balance";
+        case 422:
+            return "DeepSeek invalid request parameters";
+        case 429:
+            return "DeepSeek rate limit reached";
+        case 500:
+            return "DeepSeek server error";
+        case 503:
+            return "DeepSeek server overloaded";
+        default:
+            return `DeepSeek balance preflight failed with HTTP ${status}`;
+    }
+}
+function unavailable(checkedAt, reason, disableForRun) {
+    return {
+        provider: "deepseek",
+        available: false,
+        checkedAt,
+        reason,
+        disableForRun,
+    };
+}

package/dist/providers/deepseek/deepseek-client.d.ts

@@ -0,0 +1,53 @@
+import { ThinkingLevel } from "../thinking-levels.js";
+export interface DeepSeekChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface DeepSeekClientOptions {
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    model?: string;
+    thinking?: ThinkingLevel;
+    reasoningEffort?: "high" | "max";
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+}
+export interface DeepSeekCompleteOptions {
+    messages: DeepSeekChatMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    thinking?: ThinkingLevel;
+    reasoningEffort?: "high" | "max";
+    signal?: AbortSignal;
+}
+interface DeepSeekChatChoice {
+    finish_reason?: string;
+    message?: {
+        content?: string;
+        reasoning_content?: string;
+    };
+}
+export interface DeepSeekChatResponse {
+    choices?: DeepSeekChatChoice[];
+}
+export declare class DeepSeekClient {
+    private readonly apiKeyEnv;
+    private readonly baseUrl;
+    private readonly model;
+    private readonly thinking;
+    private readonly reasoningEffort?;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    private readonly env;
+    private readonly apiKey?;
+    constructor(options?: DeepSeekClientOptions);
+    complete(options: DeepSeekCompleteOptions): Promise<string>;
+    complete(messages: DeepSeekChatMessage[], signal?: AbortSignal): Promise<string>;
+    private extractTextContent;
+    private buildRequestBody;
+    private errorReason;
+}
+export declare function extractAssistantContent(payload: DeepSeekChatResponse): string;
+export {};

package/dist/providers/deepseek/deepseek-client.js

@@ -0,0 +1,164 @@
+import { deepseekStatusReason } from "./deepseek-balance.js";
+export class DeepSeekClient {
+    apiKeyEnv;
+    baseUrl;
+    model;
+    thinking;
+    reasoningEffort;
+    timeoutMs;
+    fetchImpl;
+    env;
+    apiKey;
+    constructor(options = {}) {
+        this.apiKeyEnv = options.apiKeyEnv ?? "DEEPSEEK_API_KEY";
+        this.baseUrl = (options.baseUrl ?? "https://api.deepseek.com").replace(/\/+$/, "");
+        this.model = options.model ?? "deepseek-v4-flash";
+        this.thinking = options.thinking ?? "max";
+        this.reasoningEffort = options.reasoningEffort ?? "max";
+        this.timeoutMs = options.timeoutMs ?? 60_000;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.env = options.env ?? process.env;
+        this.apiKey = options.apiKey ?? this.env[this.apiKeyEnv];
+    }
+    async complete(optionsOrMessages, maybeSignal) {
+        const options = Array.isArray(optionsOrMessages)
+            ? { messages: optionsOrMessages, signal: maybeSignal }
+            : optionsOrMessages;
+        if (!this.apiKey) {
+            throw new Error(`${this.apiKeyEnv} is not set`);
+        }
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort(new Error(`DeepSeek request timed out after ${this.timeoutMs}ms`));
+        }, this.timeoutMs);
+        timeout.unref?.();
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, controller.signal])
+            : controller.signal;
+        try {
+            const response = await this.fetchImpl(`${this.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(this.buildRequestBody(options)),
+                signal,
+            });
+            if (!response.ok) {
+                throw new Error(await this.errorReason(response));
+            }
+            const payload = await response.json();
+            return extractAssistantContent(payload);
+        }
+        catch (err) {
+            if (timedOut || (err instanceof Error && err.name === "AbortError" && controller.signal.aborted)) {
+                throw new Error(`DeepSeek request timed out after ${this.timeoutMs}ms`);
+            }
+            if (options.signal?.aborted) {
+                throw options.signal.reason ?? new Error("DeepSeek request aborted");
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    // Extract text content from various content formats (string, array, object)
+    // Handles: string, [{type: "text", text: "..."}], {text: "..."}, null/undefined
+    extractTextContent(content) {
+        if (typeof content === "string")
+            return content.trim();
+        if (content == null)
+            return "";
+        if (Array.isArray(content)) {
+            return content
+                .map((part) => {
+                if (typeof part === "string")
+                    return part.trim();
+                if (part && typeof part === "object" && "text" in part) {
+                    const textPart = part;
+                    return typeof textPart.text === "string" ? textPart.text.trim() : "";
+                }
+                return "";
+            })
+                .filter((text) => text.length > 0)
+                .join(" ");
+        }
+        // Fallback: coerce to string
+        return String(content ?? "").trim();
+    }
+    buildRequestBody(options) {
+        const thinking = options.thinking ?? this.thinking;
+        // SANITIZE: Remove messages with empty content to prevent DeepSeek 400 errors.
+        // Handles both string content and content array formats (e.g., [{type: "text", text: ""}]).
+        const sanitizedMessages = options.messages
+            .map((msg) => ({
+            ...msg,
+            content: this.extractTextContent(msg.content),
+        }))
+            .filter((msg) => msg.content.length > 0);
+        // Ensure at least one message exists so DeepSeek never receives an empty messages array
+        if (sanitizedMessages.length === 0) {
+            sanitizedMessages.push({ role: "user", content: "[omk] Continue with the task." });
+        }
+        // Map ThinkingLevel to DeepSeek API format
+        const isDisabled = thinking === "off" || thinking === "disabled";
+        const body = {
+            model: this.model,
+            messages: sanitizedMessages,
+            max_tokens: options.maxTokens,
+            thinking: {
+                type: isDisabled ? "disabled" : "enabled",
+            },
+        };
+        if (isDisabled) {
+            // off/disabled → keep existing behavior: set temperature
+            body.temperature = options.temperature ?? 0.2;
+        }
+        else if (thinking === "high") {
+            body.reasoning_effort = options.reasoningEffort ?? this.reasoningEffort ?? "high";
+        }
+        else if (thinking === "xhigh" || thinking === "max") {
+            body.reasoning_effort = options.reasoningEffort ?? this.reasoningEffort ?? "max";
+        }
+        // "enabled", "medium", "minimal", "low" → no reasoning_effort
+        return body;
+    }
+    async errorReason(response) {
+        const fallback = deepseekStatusReason(response.status);
+        const readText = response.text?.bind(response);
+        if (!readText)
+            return fallback;
+        try {
+            const body = await readText();
+            const summary = sanitizeErrorBody(body);
+            return summary ? `${fallback}: ${summary}` : fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+}
+export function extractAssistantContent(payload) {
+    const choice = payload.choices?.[0];
+    const content = choice?.message?.content?.trim();
+    if (content)
+        return content;
+    const reasoning = choice?.message?.reasoning_content?.trim();
+    if (reasoning) {
+        throw new Error("DeepSeek response only included reasoning_content and no final assistant content");
+    }
+    const finish = choice?.finish_reason ? ` (finish_reason=${choice.finish_reason})` : "";
+    throw new Error(`DeepSeek response did not include assistant content${finish}`);
+}
+function sanitizeErrorBody(body) {
+    return body
+        .replace(/sk-[A-Za-z0-9_-]+/g, "sk-***")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 300);
+}

package/dist/providers/deepseek/deepseek-config.d.ts

@@ -0,0 +1,89 @@
+export type DeepSeekDisabledBy = "user" | "provider-402" | "provider-availability";
+export interface DeepSeekProviderConfig {
+    enabled?: boolean;
+    disabledAt?: string;
+    disabledReason?: string;
+    disabledBy?: DeepSeekDisabledBy | string;
+    updatedAt?: string;
+    apiKeyEnv?: string;
+    model?: string;
+    kind?: "openai-compatible";
+    baseUrl?: string;
+    defaultModel?: string;
+    aliases?: Record<string, string>;
+    capabilities?: string[];
+    contextWindow?: number;
+    reservedOutputTokens?: number;
+}
+export interface GenericProviderConfig {
+    enabled?: boolean;
+    kind?: "kimi-native" | "openai-compatible" | "external-cli" | "codex-cli" | "local";
+    baseUrl?: string;
+    apiKeyEnv?: string;
+    defaultModel?: string;
+    model?: string;
+    aliases?: Record<string, string>;
+    capabilities?: string[];
+    wireApi?: string;
+    auth?: {
+        method?: string;
+    };
+    profileType?: string;
+    planKind?: string;
+    routing?: string;
+    headers?: Record<string, string>;
+    contextWindow?: number;
+    reservedOutputTokens?: number;
+    disabledAt?: string;
+    disabledReason?: string;
+    disabledBy?: string;
+    updatedAt?: string;
+}
+export interface OmkProvidersConfig {
+    version: 1;
+    providers: Record<string, GenericProviderConfig | undefined> & {
+        deepseek?: DeepSeekProviderConfig;
+    };
+}
+export interface DeepSeekConfigPathOptions {
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface DeepSeekApiKeyResolution {
+    apiKey?: string;
+    apiKeyEnv: string;
+    source?: "env" | "omk-secrets" | "opencode-secrets";
+    sourcePath?: string;
+}
+export interface DeepSeekProviderStatus {
+    provider: "deepseek";
+    enabled: boolean;
+    disabledReason?: string;
+    disabledBy?: DeepSeekDisabledBy;
+    apiKeySet: boolean;
+    apiKeySource?: DeepSeekApiKeyResolution["source"];
+    configPath: string;
+    secretsPath: string;
+}
+export declare function getDeepSeekProviderConfigPath(options?: DeepSeekConfigPathOptions): string;
+export declare function getOmkSecretsEnvPath(options?: DeepSeekConfigPathOptions): string;
+export declare function getOpenCodeSecretsEnvPath(options?: DeepSeekConfigPathOptions): string;
+export declare function readOmkProvidersConfig(options?: DeepSeekConfigPathOptions): Promise<OmkProvidersConfig>;
+export declare function writeOmkProvidersConfig(config: OmkProvidersConfig, options?: DeepSeekConfigPathOptions): Promise<string>;
+export declare function setDeepSeekEnabled(enabled: boolean, options?: DeepSeekConfigPathOptions & {
+    reason?: string;
+    disabledBy?: DeepSeekDisabledBy;
+}): Promise<DeepSeekProviderConfig>;
+export declare function forceDisableDeepSeek(reason: string, options?: DeepSeekConfigPathOptions & {
+    disabledBy?: DeepSeekDisabledBy;
+}): Promise<DeepSeekProviderConfig>;
+export declare function setDeepSeekApiKey(apiKey: string, options?: DeepSeekConfigPathOptions & {
+    apiKeyEnv?: string;
+}): Promise<{
+    secretsPath: string;
+    apiKeyEnv: string;
+}>;
+export declare function resolveDeepSeekApiKey(options?: DeepSeekConfigPathOptions & {
+    apiKeyEnv?: string;
+}): Promise<DeepSeekApiKeyResolution>;
+export declare function getDeepSeekProviderStatus(options?: DeepSeekConfigPathOptions): Promise<DeepSeekProviderStatus>;