@sema-agent/core/dist/brain/reasoning.js

Stateless, task-oriented AI agent core

const RANK = {
    off: 0,
    minimal: 1,
    low: 2,
    medium: 3,
    high: 4,
    xhigh: 5,
    max: 6,
};
export function isThinkingLevel(v) {
    return typeof v === "string" && Object.prototype.hasOwnProperty.call(RANK, v);
}
export function reasoningRequestCarried(model, reasoning) {
    return !!model.reasoning && isThinkingLevel(reasoning) && reasoning !== "off";
}
export function rankOf(level) {
    return RANK[level];
}
export const DEFAULT_EFFORT_LEVELS = ["minimal", "low", "medium", "high"];
const BINARY_FORMATS = new Set(["qwen", "zai", "qwen-chat-template"]);
export const RESPONSES_APIS = new Set(["openai-responses", "azure-openai-responses", "openai-chatgpt-responses"]);
export const MIN_THINKING_TOKENS = 1024;
export function budgetCapSkipsThinking(outputCapTokens, hardCap) {
    return hardCap && outputCapTokens < MIN_THINKING_TOKENS * 2;
}
export function declaredOffSpelling(model) {
    const compat = (model.compat ?? {});
    if (compat.supportsReasoningEffort === false)
        return undefined;
    const mapped = model.thinkingLevelMap?.off;
    return typeof mapped === "string" && mapped !== "" ? mapped : undefined;
}
export function thinkingOffSpelled(model) {
    if (!model.reasoning)
        return false;
    const compat = (model.compat ?? {});
    if (model.api === "anthropic-messages")
        return compat.thinkingMode !== "adaptive";
    if (model.api !== undefined && RESPONSES_APIS.has(model.api))
        return declaredOffSpelling(model) !== undefined;
    const format = compat.thinkingFormat ?? "openai";
    return format === "openai" ? declaredOffSpelling(model) !== undefined : true;
}
export function declaredEffortLevels(v) {
    return Array.isArray(v) && v.length > 0 ? v : undefined;
}
export function mintEffortWireValue(requested, model, allowed) {
    const resolution = resolveEffort(requested, allowed ?? DEFAULT_EFFORT_LEVELS);
    let wireValue = resolution.effective;
    const mapped = model.thinkingLevelMap?.[resolution.effective];
    if (mapped === null)
        wireValue = undefined;
    else if (mapped !== undefined)
        wireValue = mapped;
    return { resolution, wireValue };
}
export function resolveReasoning(requested, model, facts) {
    const resolved = dispatchReasoning(requested, model, facts);
    if (requested !== "off" && !reasoningRequestCarried(model, requested)) {
        return { requested, effective: "off", graded: false, clamped: true, format: resolved.format, endpoint: resolved.endpoint, dropped: true };
    }
    return resolved;
}
function dispatchReasoning(requested, model, facts) {
    const endpoint = model.api ?? "unknown";
    const compat = (model.compat ?? {});
    if (model.api === "anthropic-messages") {
        const declaredAnthropic = declaredEffortLevels(compat.effortLevels);
        if (declaredAnthropic !== undefined) {
            return { ...resolveEffort(requested, declaredAnthropic), format: "effort", endpoint };
        }
        if (requested !== "off" &&
            compat.thinkingMode !== "adaptive" &&
            facts !== undefined &&
            budgetCapSkipsThinking(facts.outputCapTokens, facts.hardOutputCap)) {
            return { requested, effective: "off", graded: false, clamped: true, format: "budget", endpoint, dropped: true };
        }
        return { requested, effective: requested, graded: true, clamped: false, format: "budget", endpoint };
    }
    if (model.api !== undefined && RESPONSES_APIS.has(model.api)) {
        if (compat.supportsReasoningEffort === false) {
            return { requested, effective: requested, graded: false, clamped: false, format: "responses", endpoint };
        }
        const responsesMint = mintEffortWireValue(requested, model, compat.reasoningEffortLevels);
        if (requested !== "off" && responsesMint.wireValue === undefined) {
            return { requested, effective: requested, graded: false, clamped: false, format: "responses", endpoint };
        }
        return { ...responsesMint.resolution, format: "responses", endpoint };
    }
    const format = compat.thinkingFormat ?? "openai";
    if (BINARY_FORMATS.has(format)) {
        return { ...resolveBinary(requested), format, endpoint };
    }
    if (!completionsEffortHonored(compat, format)) {
        return { requested, effective: requested, graded: false, clamped: false, format, endpoint };
    }
    const mint = mintEffortWireValue(requested, model, compat.reasoningEffortLevels);
    if (requested !== "off" && mint.wireValue === undefined) {
        return { requested, effective: requested, graded: false, clamped: false, format, endpoint };
    }
    return { ...mint.resolution, format, endpoint };
}
export function reasoningEffortLevelsOf(model) {
    if (!model.reasoning)
        return undefined;
    const compat = (model.compat ?? {});
    if (model.api === "anthropic-messages") {
        const declared = declaredEffortLevels(compat.effortLevels);
        return declared === undefined ? undefined : sanitizeEffortLevels(declared);
    }
    let clampSet;
    if (model.api !== undefined && RESPONSES_APIS.has(model.api)) {
        if (compat.supportsReasoningEffort === false)
            return undefined;
        clampSet = sanitizeEffortLevels(compat.reasoningEffortLevels);
    }
    else {
        const format = compat.thinkingFormat ?? "openai";
        if (BINARY_FORMATS.has(format))
            return undefined;
        if (!completionsEffortHonored(compat, format))
            return undefined;
        clampSet = sanitizeEffortLevels(compat.reasoningEffortLevels);
    }
    const honored = clampSet.filter((lvl) => model.thinkingLevelMap?.[lvl] !== null);
    return honored.length > 0 ? honored : undefined;
}
function completionsEffortHonored(compat, format) {
    const supportsEffort = compat.supportsReasoningEffort ?? true;
    return !!supportsEffort || format === "openrouter";
}
function sanitizeEffortLevels(allowed) {
    const declared = Array.isArray(allowed) ? allowed.filter((lvl) => isThinkingLevel(lvl) && lvl !== "off") : [];
    return declared.length > 0 ? declared : DEFAULT_EFFORT_LEVELS;
}
export function resolveEffort(requested, allowed = DEFAULT_EFFORT_LEVELS) {
    allowed = sanitizeEffortLevels(allowed);
    if (requested === "off" || allowed.includes(requested)) {
        return { requested, effective: requested, graded: true, clamped: false };
    }
    const reqRank = RANK[requested];
    let below;
    let lowest;
    for (const lvl of allowed) {
        if (lowest === undefined || RANK[lvl] < RANK[lowest])
            lowest = lvl;
        if (RANK[lvl] <= reqRank && (below === undefined || RANK[lvl] > RANK[below]))
            below = lvl;
    }
    const effective = below ?? lowest ?? requested;
    return { requested, effective, graded: true, clamped: effective !== requested };
}
export function resolveBinary(requested) {
    return { requested, effective: requested, graded: false, clamped: false };
}
export const REASONING_BUDGET_SHARE = {
    off: 0,
    minimal: 0.1,
    low: 0.25,
    medium: 0.4,
    high: 0.6,
    xhigh: 0.75,
    max: 0.9,
};
export function reasoningBudgetShare(level) {
    return REASONING_BUDGET_SHARE[level];
}
const REASONING_PROFILE = {
    off: { thinking: "off", awarenessGuidance: false, goalSuggested: false },
    fast: { thinking: "low", awarenessGuidance: false, goalSuggested: false },
    standard: { thinking: "medium", awarenessGuidance: false, goalSuggested: false },
    deep: { thinking: "high", awarenessGuidance: false, goalSuggested: false },
    ultra: { thinking: "max", awarenessGuidance: true, goalSuggested: false },
};
export function resolveReasoningProfile(tier) {
    return { ...REASONING_PROFILE[tier] };
}