open-multi-agent-kit 0.78.0

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

@@ -0,0 +1,272 @@
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join, posix } from "path";
+import { getUserHome } from "../../util/fs.js";
+const DEFAULT_API_KEY_ENV = "DEEPSEEK_API_KEY";
+export function getDeepSeekProviderConfigPath(options = {}) {
+    const env = options.env ?? process.env;
+    return env.OMK_PROVIDER_CONFIG_PATH ?? joinHomePath(resolveHomeDir(options), ".config", "omk", "providers.json");
+}
+export function getOmkSecretsEnvPath(options = {}) {
+    const env = options.env ?? process.env;
+    return env.OMK_SECRETS_ENV_PATH ?? joinHomePath(resolveHomeDir(options), ".config", "omk", "secrets.env");
+}
+export function getOpenCodeSecretsEnvPath(options = {}) {
+    const env = options.env ?? process.env;
+    return env.OPENCODE_SECRETS_ENV_PATH ?? joinHomePath(resolveHomeDir(options), ".config", "opencode", "secrets.env");
+}
+export async function readOmkProvidersConfig(options = {}) {
+    const path = getDeepSeekProviderConfigPath(options);
+    const raw = await readFile(path, "utf-8").catch(() => null);
+    if (!raw)
+        return emptyProvidersConfig();
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            version: 1,
+            providers: normalizeProvidersConfig(parsed.providers),
+        };
+    }
+    catch {
+        return emptyProvidersConfig();
+    }
+}
+export async function writeOmkProvidersConfig(config, options = {}) {
+    const path = getDeepSeekProviderConfigPath(options);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+    await chmod(path, 0o600).catch(() => undefined);
+    return path;
+}
+export async function setDeepSeekEnabled(enabled, options = {}) {
+    const config = await readOmkProvidersConfig(options);
+    const current = normalizeDeepSeekProviderConfig(config.providers.deepseek);
+    const updatedAt = new Date().toISOString();
+    const next = enabled
+        ? {
+            ...current,
+            enabled: true,
+            disabledAt: undefined,
+            disabledReason: undefined,
+            disabledBy: undefined,
+            updatedAt,
+        }
+        : {
+            ...current,
+            enabled: false,
+            disabledAt: updatedAt,
+            disabledReason: options.reason ?? "Disabled by user",
+            disabledBy: options.disabledBy ?? "user",
+            updatedAt,
+        };
+    await writeOmkProvidersConfig({ version: 1, providers: { ...config.providers, deepseek: next } }, options);
+    return next;
+}
+export async function forceDisableDeepSeek(reason, options = {}) {
+    const disabledBy = options.disabledBy ?? (reason.includes("402") ? "provider-402" : "provider-availability");
+    return setDeepSeekEnabled(false, { ...options, reason, disabledBy });
+}
+export async function setDeepSeekApiKey(apiKey, options = {}) {
+    const value = apiKey.trim();
+    if (!value)
+        throw new Error("DeepSeek API key is empty");
+    if (/[\r\n\0]/.test(value))
+        throw new Error("DeepSeek API key must be a single line");
+    const apiKeyEnv = options.apiKeyEnv ?? DEFAULT_API_KEY_ENV;
+    const secretsPath = getOmkSecretsEnvPath(options);
+    await upsertEnvFileValue(secretsPath, apiKeyEnv, value);
+    const config = await readOmkProvidersConfig(options);
+    const deepseek = {
+        ...normalizeDeepSeekProviderConfig(config.providers.deepseek),
+        enabled: true,
+        apiKeyEnv,
+        disabledAt: undefined,
+        disabledReason: undefined,
+        disabledBy: undefined,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeOmkProvidersConfig({ version: 1, providers: { ...config.providers, deepseek } }, options);
+    return { secretsPath, apiKeyEnv };
+}
+export async function resolveDeepSeekApiKey(options = {}) {
+    const config = await readOmkProvidersConfig(options);
+    const apiKeyEnv = options.apiKeyEnv ?? config.providers.deepseek?.apiKeyEnv ?? DEFAULT_API_KEY_ENV;
+    const env = options.env ?? process.env;
+    const envValue = env[apiKeyEnv]?.trim();
+    if (envValue)
+        return { apiKey: envValue, apiKeyEnv, source: "env" };
+    const omkSecretsPath = getOmkSecretsEnvPath(options);
+    const omkValue = await readEnvFileValue(omkSecretsPath, apiKeyEnv);
+    if (omkValue)
+        return { apiKey: omkValue, apiKeyEnv, source: "omk-secrets", sourcePath: omkSecretsPath };
+    const opencodeSecretsPath = getOpenCodeSecretsEnvPath(options);
+    const opencodeValue = await readEnvFileValue(opencodeSecretsPath, apiKeyEnv);
+    if (opencodeValue) {
+        return { apiKey: opencodeValue, apiKeyEnv, source: "opencode-secrets", sourcePath: opencodeSecretsPath };
+    }
+    return { apiKeyEnv };
+}
+export async function getDeepSeekProviderStatus(options = {}) {
+    const [config, key] = await Promise.all([
+        readOmkProvidersConfig(options),
+        resolveDeepSeekApiKey(options),
+    ]);
+    const deepseek = normalizeDeepSeekProviderConfig(config.providers.deepseek);
+    const enabled = deepseek.enabled !== false;
+    return {
+        provider: "deepseek",
+        enabled,
+        disabledReason: deepseek.disabledReason,
+        disabledBy: isDeepSeekDisabledBy(deepseek.disabledBy) ? deepseek.disabledBy : undefined,
+        apiKeySet: Boolean(key.apiKey),
+        apiKeySource: key.source,
+        configPath: getDeepSeekProviderConfigPath(options),
+        secretsPath: getOmkSecretsEnvPath(options),
+    };
+}
+function resolveHomeDir(options) {
+    return options.homeDir ?? getUserHome(options.env ?? process.env);
+}
+function joinHomePath(homeDir, ...parts) {
+    return isPosixStyleHome(homeDir) ? posix.join(homeDir, ...parts) : join(homeDir, ...parts);
+}
+function isPosixStyleHome(homeDir) {
+    return homeDir.startsWith("/") && !homeDir.startsWith("//") && !homeDir.includes("\\");
+}
+function emptyProvidersConfig() {
+    return {
+        version: 1,
+        providers: {},
+    };
+}
+function normalizeProvidersConfig(value) {
+    if (!isRecord(value))
+        return {};
+    const providers = {};
+    for (const [id, raw] of Object.entries(value)) {
+        if (id === "deepseek") {
+            providers[id] = normalizeDeepSeekProviderConfig(raw);
+        }
+        else {
+            providers[id] = normalizeGenericProviderConfig(raw);
+        }
+    }
+    return providers;
+}
+function normalizeDeepSeekProviderConfig(value) {
+    if (!isRecord(value))
+        return {};
+    return {
+        enabled: typeof value.enabled === "boolean" ? value.enabled : undefined,
+        disabledAt: typeof value.disabledAt === "string" ? value.disabledAt : undefined,
+        disabledReason: typeof value.disabledReason === "string" ? value.disabledReason : undefined,
+        disabledBy: typeof value.disabledBy === "string" && value.disabledBy.trim() ? value.disabledBy : undefined,
+        updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : undefined,
+        apiKeyEnv: typeof value.apiKeyEnv === "string" && value.apiKeyEnv.trim() ? value.apiKeyEnv : undefined,
+        model: typeof value.model === "string" && value.model.trim() ? value.model : undefined,
+        kind: value.kind === "openai-compatible" ? value.kind : undefined,
+        baseUrl: typeof value.baseUrl === "string" && value.baseUrl.trim() ? value.baseUrl : undefined,
+        defaultModel: typeof value.defaultModel === "string" && value.defaultModel.trim() ? value.defaultModel : undefined,
+        aliases: normalizeStringMap(value.aliases),
+        capabilities: normalizeStringList(value.capabilities),
+        contextWindow: normalizePositiveInteger(value.contextWindow),
+        reservedOutputTokens: normalizePositiveInteger(value.reservedOutputTokens),
+    };
+}
+function normalizeGenericProviderConfig(value) {
+    if (!isRecord(value))
+        return {};
+    return {
+        enabled: typeof value.enabled === "boolean" ? value.enabled : undefined,
+        kind: isProviderKind(value.kind) ? value.kind : undefined,
+        baseUrl: typeof value.baseUrl === "string" && value.baseUrl.trim() ? value.baseUrl : undefined,
+        apiKeyEnv: typeof value.apiKeyEnv === "string" && value.apiKeyEnv.trim() ? value.apiKeyEnv : undefined,
+        defaultModel: typeof value.defaultModel === "string" && value.defaultModel.trim() ? value.defaultModel : undefined,
+        model: typeof value.model === "string" && value.model.trim() ? value.model : undefined,
+        aliases: normalizeStringMap(value.aliases),
+        capabilities: normalizeStringList(value.capabilities),
+        contextWindow: normalizePositiveInteger(value.contextWindow),
+        reservedOutputTokens: normalizePositiveInteger(value.reservedOutputTokens),
+        disabledAt: typeof value.disabledAt === "string" ? value.disabledAt : undefined,
+        disabledReason: typeof value.disabledReason === "string" ? value.disabledReason : undefined,
+        disabledBy: typeof value.disabledBy === "string" && value.disabledBy.trim() ? value.disabledBy : undefined,
+        updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : undefined,
+    };
+}
+function normalizeStringMap(value) {
+    if (!isRecord(value))
+        return undefined;
+    const entries = Object.entries(value)
+        .filter((entry) => typeof entry[1] === "string" && entry[1].trim().length > 0);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizeStringList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const list = value.filter((item) => typeof item === "string" && item.trim().length > 0)
+        .map((item) => item.trim());
+    return list.length > 0 ? [...new Set(list)] : undefined;
+}
+function normalizePositiveInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isDeepSeekDisabledBy(value) {
+    return value === "user" || value === "provider-402" || value === "provider-availability";
+}
+function isProviderKind(value) {
+    return value === "kimi-native" || value === "openai-compatible" || value === "codex-cli" || value === "local";
+}
+async function upsertEnvFileValue(path, name, value) {
+    const existing = await readFile(path, "utf-8").catch(() => "");
+    const linePattern = new RegExp(`^\\s*(?:export\\s+)?${escapeRegExp(name)}\\s*=`);
+    const nextLine = `export ${name}=${shellSingleQuote(value)}`;
+    let replaced = false;
+    const lines = existing.split(/\r?\n/).filter((line, index, all) => !(index === all.length - 1 && line === ""));
+    const nextLines = lines.map((line) => {
+        if (linePattern.test(line)) {
+            replaced = true;
+            return nextLine;
+        }
+        return line;
+    });
+    if (!replaced)
+        nextLines.push(nextLine);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, nextLines.join("\n") + "\n", { mode: 0o600 });
+    await chmod(path, 0o600).catch(() => undefined);
+}
+async function readEnvFileValue(path, name) {
+    const raw = await readFile(path, "utf-8").catch(() => null);
+    if (!raw)
+        return undefined;
+    const linePattern = new RegExp(`^\\s*(?:export\\s+)?${escapeRegExp(name)}\\s*=\\s*(.*)\\s*$`);
+    for (const line of raw.split(/\r?\n/)) {
+        const match = line.match(linePattern);
+        if (!match)
+            continue;
+        const parsed = parseEnvValue(match[1] ?? "");
+        if (parsed.trim())
+            return parsed.trim();
+    }
+    return undefined;
+}
+function parseEnvValue(raw) {
+    const value = raw.trim();
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1).replace(/'\\''/g, "'");
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    return value.replace(/\s+#.*$/, "").trim();
+}
+function shellSingleQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -0,0 +1,5 @@
+import type { TaskResult } from "../../contracts/orchestration.js";
+import type { ProviderFailureKind } from "../types.js";
+export declare function isDeepSeekPaymentOrAvailabilityFailure(result: TaskResult): boolean;
+export declare function isDeepSeekTransientFailure(result: TaskResult): boolean;
+export declare function classifyDeepSeekFailure(result: TaskResult): ProviderFailureKind;

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

@@ -0,0 +1,48 @@
+const AVAILABILITY_PATTERNS = [
+    "402",
+    "insufficient balance",
+    "balance",
+    "api key",
+    "authentication",
+    "unauthorized",
+    "401",
+];
+const TRANSIENT_PATTERNS = [
+    // NOTE: "text content is empty" was removed — it is a Moonshot (Kimi) API error,
+    // not a DeepSeek error. It occurs when Kimi CLI < 1.39.0 sends assistant messages
+    // with tool_calls but empty content. See Kimi CLI changelog 2026-04-24.
+    "rate limit",
+    "429",
+    "server overloaded",
+    "overloaded",
+    "server error",
+    "500",
+    "503",
+    "timeout",
+    "timed out",
+    "econnreset",
+    "socket hang up",
+    "fetch failed",
+];
+const POLICY_PATTERNS = [
+    "read-only",
+    "does not receive tool",
+    "mcp authority",
+    "write/shell/merge",
+];
+export function isDeepSeekPaymentOrAvailabilityFailure(result) {
+    return classifyDeepSeekFailure(result) === "availability";
+}
+export function isDeepSeekTransientFailure(result) {
+    return classifyDeepSeekFailure(result) === "transient";
+}
+export function classifyDeepSeekFailure(result) {
+    const text = `${result.stderr}\n${result.stdout}`.toLowerCase();
+    if (AVAILABILITY_PATTERNS.some((pattern) => text.includes(pattern)))
+        return "availability";
+    if (TRANSIENT_PATTERNS.some((pattern) => text.includes(pattern)))
+        return "transient";
+    if (POLICY_PATTERNS.some((pattern) => text.includes(pattern)))
+        return "policy";
+    return "unknown";
+}

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

@@ -0,0 +1,10 @@
+import type { TaskRunner } from "../../contracts/orchestration.js";
+import { type DeepSeekClientOptions } from "./deepseek-client.js";
+export interface DeepSeekReadOnlyRunnerOptions extends DeepSeekClientOptions {
+    promptPrefix?: string;
+    allowAdvisoryFileNodes?: boolean;
+    contextWindow?: number;
+    reservedOutputTokens?: number;
+    safetyMarginTokens?: number;
+}
+export declare function createDeepSeekReadOnlyTaskRunner(options?: DeepSeekReadOnlyRunnerOptions): TaskRunner;

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

@@ -0,0 +1,162 @@
+import { renderPromptDigest } from "../../goal/prompt-digest.js";
+import { inferNodeRisk } from "../router.js";
+import { DeepSeekClient } from "./deepseek-client.js";
+import { contextPreflightErrorMessage, preflightProviderMessages, } from "../context-preflight.js";
+export function createDeepSeekReadOnlyTaskRunner(options = {}) {
+    let currentOnThinking;
+    const runner = {
+        get onThinking() {
+            return currentOnThinking;
+        },
+        set onThinking(fn) {
+            currentOnThinking = fn;
+        },
+        fork(onThinking) {
+            const forked = createDeepSeekReadOnlyTaskRunner(options);
+            forked.onThinking = onThinking;
+            return forked;
+        },
+        async run(node, env, signal) {
+            const risk = inferNodeRisk(node);
+            const advisoryFileMode = options.allowAdvisoryFileNodes === true &&
+                env.OMK_DEEPSEEK_PARTICIPATION === "advisory" &&
+                risk === "write";
+            if (risk !== "read" && !advisoryFileMode) {
+                return deny(node, "DeepSeek runner is read-only; write/shell/merge nodes stay on the authority provider");
+            }
+            if (node.routing?.requiresToolCalling === true || node.routing?.requiresMcp === true) {
+                return deny(node, "DeepSeek runner does not receive tool or MCP authority in alpha");
+            }
+            const model = env.OMK_DEEPSEEK_MODEL || options.model;
+            const reasoningEffort = parseDeepSeekReasoningEffort(env.OMK_DEEPSEEK_REASONING_EFFORT) ?? options.reasoningEffort;
+            currentOnThinking?.(`DeepSeek ${env.OMK_DEEPSEEK_MODEL_TIER ?? "flash"} ${env.OMK_DEEPSEEK_PARTICIPATION ?? "direct"} worker: ${node.name}`);
+            const client = new DeepSeekClient({
+                ...options,
+                model,
+                reasoningEffort,
+            });
+            try {
+                const messages = [
+                    {
+                        role: "system",
+                        content: [
+                            "You are a DeepSeek read-only worker inside OMK.",
+                            "The configured authority provider is the main orchestrator and final reviewer.",
+                            "Do not claim file writes, shell execution, secret access, MCP access, or merge authority.",
+                            "Do not echo the original user input or objective; synthesize from digests, node state, and evidence.",
+                            advisoryFileMode
+                                ? "For this file-affecting node, provide advisory patch strategy only; the configured authority provider will perform actual file edits."
+                                : "",
+                            "Return concise findings, evidence, risks, and recommended authority-provider follow-up.",
+                        ].filter(Boolean).join(" ") || "You are a DeepSeek read-only worker. Provide analysis for the given node.",
+                    },
+                    { role: "user", content: buildDeepSeekNodePrompt(node, env, options.promptPrefix) },
+                ];
+                const preflight = await preflightProviderMessages(messages, {
+                    provider: "deepseek",
+                    model,
+                    contextWindow: options.contextWindow,
+                    reservedOutputTokens: options.reservedOutputTokens ?? 4096,
+                    safetyMarginTokens: options.safetyMarginTokens,
+                    runId: env.OMK_RUN_ID,
+                    nodeId: node.id,
+                    projectRoot: env.OMK_PROJECT_ROOT,
+                });
+                if (!preflight.ok) {
+                    return {
+                        success: false,
+                        exitCode: 1,
+                        stdout: "",
+                        stderr: contextPreflightErrorMessage(preflight.report),
+                        metadata: { contextPreflight: preflight.report },
+                    };
+                }
+                const content = await client.complete({
+                    messages: preflight.messages.map((message) => ({
+                        role: message.role === "assistant" ? "assistant" : message.role === "system" ? "system" : "user",
+                        content: message.content,
+                    })),
+                    maxTokens: 4096,
+                    thinking: options.thinking,
+                    reasoningEffort: options.reasoningEffort,
+                    signal,
+                });
+                return {
+                    success: true,
+                    exitCode: 0,
+                    stdout: `[${node.id}:${node.role}:deepseek] ${content}\n`,
+                    stderr: "",
+                    metadata: preflight.report.compacted ? { contextPreflight: preflight.report } : undefined,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: err instanceof Error ? err.message : String(err),
+                };
+            }
+        },
+    };
+    return runner;
+}
+function parseDeepSeekReasoningEffort(value) {
+    return value === "high" || value === "max" ? value : undefined;
+}
+function deny(node, reason) {
+    return {
+        success: false,
+        exitCode: 1,
+        stdout: "",
+        stderr: `[${node.id}:${node.role}] ${reason}`,
+    };
+}
+function buildDeepSeekNodePrompt(node, env, promptPrefix) {
+    const result = [
+        promptPrefix?.trim(),
+        `DAG node: ${node.id}`,
+        `Name: ${node.name}`,
+        `Role: ${node.role}`,
+        `Task type: ${env.OMK_TASK_TYPE ?? "general"}`,
+        `Complexity: ${env.OMK_COMPLEXITY ?? "moderate"}`,
+        `DeepSeek model: ${env.OMK_DEEPSEEK_MODEL ?? "default"}`,
+        `DeepSeek participation: ${env.OMK_DEEPSEEK_PARTICIPATION ?? "direct"}`,
+        `Provider route confidence: ${env.OMK_PROVIDER_ROUTE_CONFIDENCE ?? "unknown"}`,
+        `DeepSeek invocation key: ${env.OMK_DEEPSEEK_INVOCATION_KEY ?? env.OMK_PROVIDER_INVOCATION_KEY ?? "unknown"}`,
+        `Provider route reason: ${env.OMK_PROVIDER_ROUTE_REASON ?? ""}`,
+        `Routing rationale: ${node.routing?.rationale ?? ""}`,
+        renderPromptDigest("Goal context digest from authority provider", env.OMK_GOAL_CONTEXT ?? env.OMK_GOAL, {
+            maxKeywords: 18,
+            maxPhrases: 3,
+        }),
+        renderOptionalSection("DeepSeek advisory context", env.OMK_DEEPSEEK_ADVISORY),
+        renderList("Inputs", (node.inputs ?? []).map((input) => `${input.name}: ${input.ref}${input.from ? ` from ${input.from}` : ""}`)),
+        renderList("Outputs", (node.outputs ?? []).map((output) => `${output.name}${output.gate ? ` (${output.gate})` : ""}${output.ref ? ` -> ${output.ref}` : ""}`)),
+        renderList("Skills visible to authority provider", node.routing?.skills ?? []),
+        renderList("MCP hints visible to authority provider only", node.routing?.mcpServers ?? [], { showWhenEmpty: true }),
+        renderList("Tool hints visible to authority provider only", node.routing?.tools ?? [], { showWhenEmpty: true }),
+        "Required output:",
+        "- Summary",
+        "- Evidence or file/symbol references if known",
+        "- Risks/unknowns",
+        "- Recommended authority-provider follow-up",
+        "- Do not echo the original user input; return synthesized findings only",
+    ].filter((section) => Boolean(section)).join("\n");
+    // Ensure the prompt is never empty — DeepSeek rejects empty content with 400
+    return result.trim() || `Analyze DAG node ${node.id} (${node.name}) and provide findings.`;
+}
+function renderList(title, items, options = {}) {
+    if (items.length === 0)
+        return options.showWhenEmpty === true ? `${title}:\n- none` : "";
+    return `${title}:\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+function renderOptionalSection(title, value, maxChars = 6_000) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return "";
+    const content = trimmed.length <= maxChars
+        ? trimmed
+        : `${trimmed.slice(0, maxChars)}\n\n[truncated: ${trimmed.length - maxChars} chars omitted]`;
+    return `${title}:\n${content}`;
+}

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

@@ -0,0 +1,31 @@
+import type { DagNode } from "../../orchestration/dag.js";
+/**
+ * Super OMK DeepSeek + Authority-Provider Co-Orchestration Preset
+ *
+ * This preset maximizes DeepSeek V4 Pro utilization alongside the configured authority provider:
+ * - DeepSeek handles: planning, review, analysis, reasoning-heavy tasks
+ * - Authority provider handles: file edits, shell execution, MCP/tools, final merge
+ * - Parallel worker cap increased for DeepSeek advisory lanes
+ */
+export interface SuperOmkConfig {
+    parallelWorkers: number;
+    deepseekWorkerCap: number;
+    kimiWorkerCap: number;
+    authorityWorkerCap: number;
+    deepseekNodeTypes: string[];
+    kimiNodeTypes: string[];
+    authorityNodeTypes: string[];
+    deepseekModel: string;
+    deepseekReasoningEffort: "high" | "max";
+    kimiModel: string;
+    authorityModel: string;
+    deepseekFallbackToKimi: boolean;
+    deepseekFallbackToAuthority: boolean;
+    retryEmptyContent: boolean;
+    deepseekAdvisoryEnabled: boolean;
+    deepseekAdvisoryRatio: number;
+}
+export declare const SUPER_OMK_DEFAULTS: SuperOmkConfig;
+export declare function isSuperOmkEnabled(env?: Record<string, string | undefined>): boolean;
+export declare function getSuperOmkConfig(env?: Record<string, string | undefined>): SuperOmkConfig;
+export declare function matchesDeepSeekNodeType(node: DagNode, env: Record<string, string>, config: SuperOmkConfig): boolean;

package/dist/providers/deepseek/deepseek-super-config.js

@@ -0,0 +1,136 @@
+export const SUPER_OMK_DEFAULTS = {
+    parallelWorkers: 4,
+    deepseekWorkerCap: 3,
+    kimiWorkerCap: 2,
+    authorityWorkerCap: 2,
+    deepseekNodeTypes: ["plan", "review", "analyze", "research", "debug"],
+    kimiNodeTypes: ["implement", "edit", "shell", "test", "merge"],
+    authorityNodeTypes: ["implement", "edit", "shell", "test", "merge"],
+    deepseekModel: "deepseek-v4-pro",
+    deepseekReasoningEffort: "max",
+    kimiModel: "kimi-k2-6",
+    authorityModel: "kimi-k2-6",
+    deepseekFallbackToKimi: true,
+    deepseekFallbackToAuthority: true,
+    retryEmptyContent: true,
+    deepseekAdvisoryEnabled: true,
+    deepseekAdvisoryRatio: 0.7,
+};
+const DEEPSEEK_TYPE_ALIASES = {
+    plan: ["planner", "architect", "coordinator"],
+    review: ["reviewer", "auditor", "aggregator"],
+    analyze: ["explorer", "researcher", "analyzer"],
+    research: ["researcher", "explorer", "documenter"],
+    debug: ["debugger", "tester", "qa"],
+};
+export function isSuperOmkEnabled(env) {
+    const profile = env?.OMK_RESOURCE_PROFILE ?? process.env.OMK_RESOURCE_PROFILE;
+    if (profile === "super")
+        return true;
+    const enabled = env?.OMK_SUPER_OMK_ENABLED ?? process.env.OMK_SUPER_OMK_ENABLED;
+    return enabled === "1" || enabled === "true";
+}
+export function getSuperOmkConfig(env) {
+    const config = { ...SUPER_OMK_DEFAULTS };
+    if (!env)
+        return config;
+    const parseIntEnv = (key, min) => {
+        const v = env[key];
+        if (v === undefined)
+            return undefined;
+        const n = Number(v);
+        return Number.isFinite(n) && n >= min ? Math.floor(n) : undefined;
+    };
+    const parseFloatEnv = (key, min) => {
+        const v = env[key];
+        if (v === undefined)
+            return undefined;
+        const n = Number(v);
+        return Number.isFinite(n) && n >= min ? n : undefined;
+    };
+    const workers = parseIntEnv("OMK_PARALLEL_WORKERS", 1);
+    if (workers !== undefined)
+        config.parallelWorkers = workers;
+    const dsCap = parseIntEnv("OMK_DEEPSEEK_WORKER_CAP", 1);
+    if (dsCap !== undefined)
+        config.deepseekWorkerCap = dsCap;
+    const kmCap = parseIntEnv("OMK_KIMI_WORKER_CAP", 1);
+    if (kmCap !== undefined)
+        config.kimiWorkerCap = kmCap;
+    const authorityCap = parseIntEnv("OMK_AUTHORITY_WORKER_CAP", 1);
+    config.authorityWorkerCap = authorityCap ?? config.kimiWorkerCap;
+    if (authorityCap !== undefined)
+        config.kimiWorkerCap = authorityCap;
+    if (env.OMK_DEEPSEEK_NODE_TYPES) {
+        config.deepseekNodeTypes = env.OMK_DEEPSEEK_NODE_TYPES.split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    if (env.OMK_KIMI_NODE_TYPES) {
+        config.kimiNodeTypes = env.OMK_KIMI_NODE_TYPES.split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        config.authorityNodeTypes = config.kimiNodeTypes;
+    }
+    if (env.OMK_AUTHORITY_NODE_TYPES) {
+        config.authorityNodeTypes = env.OMK_AUTHORITY_NODE_TYPES.split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        config.kimiNodeTypes = config.authorityNodeTypes;
+    }
+    if (env.OMK_DEEPSEEK_MODEL)
+        config.deepseekModel = env.OMK_DEEPSEEK_MODEL;
+    if (env.OMK_DEEPSEEK_REASONING_EFFORT === "high" || env.OMK_DEEPSEEK_REASONING_EFFORT === "max") {
+        config.deepseekReasoningEffort = env.OMK_DEEPSEEK_REASONING_EFFORT;
+    }
+    if (env.OMK_KIMI_MODEL)
+        config.kimiModel = env.OMK_KIMI_MODEL;
+    config.authorityModel = config.kimiModel;
+    if (env.OMK_AUTHORITY_MODEL) {
+        config.authorityModel = env.OMK_AUTHORITY_MODEL;
+        config.kimiModel = env.OMK_AUTHORITY_MODEL;
+    }
+    const fallback = env.OMK_DEEPSEEK_FALLBACK_TO_KIMI;
+    if (fallback !== undefined)
+        config.deepseekFallbackToKimi = fallback === "1" || fallback === "true";
+    config.deepseekFallbackToAuthority = config.deepseekFallbackToKimi;
+    const authorityFallback = env.OMK_DEEPSEEK_FALLBACK_TO_AUTHORITY;
+    if (authorityFallback !== undefined) {
+        config.deepseekFallbackToAuthority = authorityFallback === "1" || authorityFallback === "true";
+        config.deepseekFallbackToKimi = config.deepseekFallbackToAuthority;
+    }
+    const retry = env.OMK_RETRY_EMPTY_CONTENT;
+    if (retry !== undefined)
+        config.retryEmptyContent = retry === "1" || retry === "true";
+    const advisory = env.OMK_DEEPSEEK_ADVISORY_ENABLED;
+    if (advisory !== undefined)
+        config.deepseekAdvisoryEnabled = advisory === "1" || advisory === "true";
+    const ratio = parseFloatEnv("OMK_DEEPSEEK_ADVISORY_RATIO", 0);
+    if (ratio !== undefined)
+        config.deepseekAdvisoryRatio = Math.min(1, ratio);
+    return config;
+}
+export function matchesDeepSeekNodeType(node, env, config) {
+    const role = node.role.toLowerCase();
+    const taskType = (env.OMK_TASK_TYPE ?? "general").toLowerCase();
+    for (const type of config.deepseekNodeTypes) {
+        const t = type.toLowerCase();
+        // Direct match
+        if (role === t || taskType === t)
+            return true;
+        // Substring match
+        if (role.includes(t) || t.includes(role))
+            return true;
+        if (taskType.includes(t) || t.includes(taskType))
+            return true;
+        // Alias match
+        const aliases = DEEPSEEK_TYPE_ALIASES[t];
+        if (aliases) {
+            for (const alias of aliases) {
+                if (role === alias || role.includes(alias) || alias.includes(role))
+                    return true;
+            }
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,8 @@
+import type { AgentProvider } from "./provider.js";
+import type { TaskRunner } from "../contracts/orchestration.js";
+export interface DeepSeekProviderOptions {
+    runner: TaskRunner;
+    priority?: number;
+    maxRetries?: number;
+}
+export declare function createDeepSeekProvider(options: DeepSeekProviderOptions): AgentProvider;