@sema-agent/core 5.6.0 → 5.8.0

package/dist/bin/tb-env.js

@@ -1,17 +0,0 @@
-export function positiveIntFromEnv(name, env = process.env) {
-    const raw = env[name];
-    if (raw === undefined)
-        return undefined;
-    const s = raw.trim();
-    if (s === "")
-        return undefined;
-    const n = /^[0-9]+$/.test(s) ? Number(s) : NaN;
-    if (!Number.isSafeInteger(n) || n <= 0) {
-        process.stderr.write(`sema-tb: ignoring ${name}=${JSON.stringify(raw)} — expected a positive integer.\n`);
-        return undefined;
-    }
-    return n;
-}
-export function tbModelInput(env = process.env) {
-    return env.TB_VISION === "1" ? ["text", "image"] : ["text"];
-}

package/dist/brain/walltime.d.ts

@@ -1 +0,0 @@
-export declare const WALLTIME_CUTOFF_MESSAGE = "walltime cutoff: the response crossed the task's soft wall-clock deadline and was cut off to preserve a write-out window";

package/dist/brain/walltime.js

@@ -1 +0,0 @@
-export const WALLTIME_CUTOFF_MESSAGE = "walltime cutoff: the response crossed the task's soft wall-clock deadline and was cut off to preserve a write-out window";

package/dist/core/runner/call-cap.d.ts

@@ -1,67 +0,0 @@
-export declare const CALL_CAP_PRIOR_TOK_PER_SEC = 40;
-export declare const CALL_CAP_SAFETY = 0.5;
-export declare const CALL_CAP_MIN_FLOOR = 1024;
-export declare const CALL_CAP_THINKING_MIN = 2048;
-export declare const WRITEOUT_CUSHION_MAX_MS = 75000;
-export declare const WRITEOUT_CUSHION_MIN_MS = 10000;
-export declare const CUSHION_LATENCY_FACTOR = 2;
-export declare const CUSHION_BUDGET_FRACTION = 0.4;
-export declare const FINAL_WRITEOUT_MARGIN_MS = 5000;
-export declare const TTFT_WINDOW_FACTOR = 2;
-export declare const TTFT_PRIOR_MS = 5000;
-export declare const WRITEOUT_WINDOW_NO_SAMPLE_FLOOR_MS = 1000;
-export declare const TOOL_CUT_WRITEOUT_RESERVE_MS = 5000;
-export declare const TOOL_CUT_DEADLINE_LAG_MS = 2500;
-export declare const TOOL_CUT_MIN_WINDOW_MS = 10000;
-export declare const TOOL_CUT_FLOOR_GRACE_MS = 2000;
-export declare const WALLTIME_STALL_CONNECT_MS = 30000;
-export declare const WALLTIME_STALL_FIRST_TOKEN_MS = 120000;
-export declare const WALLTIME_STALL_IDLE_MS = 90000;
-export declare function writeoutCushionMs(budgetMs: number): number;
-export interface CallCapState {
-    emaTokPerSec?: number;
-    emaCallMs?: number;
-    emaToolMs?: number;
-    peakCallMs?: number;
-    peakToolMs?: number;
-    recentCallMs?: number[];
-    recentToolMs?: number[];
-    ttftEwma?: number;
-    last?: {
-        cap: number;
-        remainingMs: number;
-        tokPerSec: number;
-        thinkingSkipped: boolean;
-    };
-}
-export interface CallCapRef {
-    state: CallCapState;
-    deadlineMs?: number;
-    finalizeMode?: boolean;
-    staticCapTokens?: number;
-    shrinks?: number;
-    cushionMs?: number;
-    budgetMs?: number;
-    toolClamps?: number;
-    toolCuts?: number;
-    pendingCutTools?: number;
-    reasoningObserved?: boolean;
-}
-export declare function effectiveCushionMs(ref: CallCapRef): number | undefined;
-export declare function minLiveWriteoutWindowMs(state: CallCapState): number;
-export declare function softExecDeadlineMs(ref: CallCapRef): number | undefined;
-export declare function createCallCapRef(): CallCapRef;
-export declare function toolCutDeadlineMs(ref: CallCapRef, nowMs: number): number | undefined;
-export declare function hasRealContent(content: ReadonlyArray<{
-    type?: unknown;
-    text?: unknown;
-    thinking?: unknown;
-}> | undefined): boolean;
-export declare function recordCallSample(state: CallCapState, outputTokens: number, latencyMs: number, opts?: {
-    contentValid?: boolean;
-}): void;
-export declare function recordTtftSample(state: CallCapState, ttftMs: number): void;
-export declare function recordToolSample(state: CallCapState, durationMs: number): void;
-export declare function recordToolCycleSample(state: CallCapState, wallSpanMs: number): void;
-export declare function computeCallCap(ref: CallCapRef, nowMs: number, thinkingActive: boolean): number | undefined;
-export declare function estimateCycleMs(state: CallCapState): number;

package/dist/core/runner/call-cap.js

@@ -1,145 +0,0 @@
-const EWMA_ALPHA = 0.4;
-export const CALL_CAP_PRIOR_TOK_PER_SEC = 40;
-export const CALL_CAP_SAFETY = 0.5;
-export const CALL_CAP_MIN_FLOOR = 1024;
-export const CALL_CAP_THINKING_MIN = 2048;
-const FINALIZE_HEADROOM = 1.5;
-const FINALIZE_PRIOR_CYCLE_MS = 60_000;
-const PEAK_DECAY = 0.85;
-const CYCLE_RING_SIZE = 8;
-const CYCLE_PERCENTILE = 0.75;
-export const WRITEOUT_CUSHION_MAX_MS = 75_000;
-export const WRITEOUT_CUSHION_MIN_MS = 10_000;
-export const CUSHION_LATENCY_FACTOR = 2;
-export const CUSHION_BUDGET_FRACTION = 0.4;
-export const FINAL_WRITEOUT_MARGIN_MS = 5_000;
-export const TTFT_WINDOW_FACTOR = 2;
-export const TTFT_PRIOR_MS = 5_000;
-export const WRITEOUT_WINDOW_NO_SAMPLE_FLOOR_MS = 1_000;
-export const TOOL_CUT_WRITEOUT_RESERVE_MS = 5_000;
-export const TOOL_CUT_DEADLINE_LAG_MS = 2_500;
-export const TOOL_CUT_MIN_WINDOW_MS = 10_000;
-export const TOOL_CUT_FLOOR_GRACE_MS = 2_000;
-export const WALLTIME_STALL_CONNECT_MS = 30_000;
-export const WALLTIME_STALL_FIRST_TOKEN_MS = 120_000;
-export const WALLTIME_STALL_IDLE_MS = 90_000;
-export function writeoutCushionMs(budgetMs) {
-    return Math.min(WRITEOUT_CUSHION_MAX_MS, Math.max(WRITEOUT_CUSHION_MIN_MS, Math.floor(budgetMs * 0.15)));
-}
-export function effectiveCushionMs(ref) {
-    const base = ref.cushionMs;
-    if (base === undefined)
-        return undefined;
-    const budgetCapMs = ref.budgetMs !== undefined ? Math.floor(ref.budgetMs * CUSHION_BUDGET_FRACTION) : Infinity;
-    const smallWindow = (ref.state.recentCallMs?.length ?? 0) < 3;
-    const observedRaw = Math.max(ref.state.peakCallMs ?? 0, ref.state.emaCallMs ?? 0);
-    const observedCallMs = smallWindow ? Math.min(observedRaw, FINALIZE_PRIOR_CYCLE_MS) : observedRaw;
-    const dynamic = observedCallMs > 0 ? Math.min(CUSHION_LATENCY_FACTOR * observedCallMs, budgetCapMs) : 0;
-    const ttftFloor = Math.min(FINAL_WRITEOUT_MARGIN_MS + TTFT_WINDOW_FACTOR * (ref.state.ttftEwma ?? TTFT_PRIOR_MS), budgetCapMs);
-    return Math.max(base, Math.ceil(dynamic), Math.ceil(ttftFloor));
-}
-export function minLiveWriteoutWindowMs(state) {
-    return state.ttftEwma !== undefined
-        ? Math.ceil(TTFT_WINDOW_FACTOR * state.ttftEwma)
-        : WRITEOUT_WINDOW_NO_SAMPLE_FLOOR_MS;
-}
-export function softExecDeadlineMs(ref) {
-    const d = ref.deadlineMs;
-    const c = effectiveCushionMs(ref);
-    if (d === undefined || c === undefined)
-        return undefined;
-    return ref.finalizeMode ? d - FINAL_WRITEOUT_MARGIN_MS : d - c;
-}
-export function createCallCapRef() {
-    return { state: {} };
-}
-export function toolCutDeadlineMs(ref, nowMs) {
-    const soft = softExecDeadlineMs(ref);
-    if (soft === undefined)
-        return undefined;
-    const raw = Math.max(soft + TOOL_CUT_DEADLINE_LAG_MS, nowMs + TOOL_CUT_MIN_WINDOW_MS);
-    const ttftReserve = ref.state.ttftEwma !== undefined ? Math.ceil(TTFT_WINDOW_FACTOR * ref.state.ttftEwma) : 0;
-    const hardCap = ref.deadlineMs - FINAL_WRITEOUT_MARGIN_MS - Math.max(TOOL_CUT_WRITEOUT_RESERVE_MS, ttftReserve);
-    const clamped = Math.min(raw, hardCap);
-    return clamped > nowMs ? clamped : nowMs + TOOL_CUT_FLOOR_GRACE_MS;
-}
-export function hasRealContent(content) {
-    if (!Array.isArray(content))
-        return false;
-    return content.some((c) => (c?.type === "text" && typeof c.text === "string" && c.text.length > 0) ||
-        c?.type === "toolCall" ||
-        (c?.type === "thinking" && typeof c.thinking === "string" && (c.thinking.length > 0)));
-}
-export function recordCallSample(state, outputTokens, latencyMs, opts) {
-    const latencyHonest = latencyMs > 0 && (outputTokens > 0 || opts?.contentValid === true);
-    if (latencyHonest) {
-        state.emaCallMs = state.emaCallMs === undefined ? latencyMs : EWMA_ALPHA * latencyMs + (1 - EWMA_ALPHA) * state.emaCallMs;
-        state.peakCallMs = Math.max(latencyMs, (state.peakCallMs ?? 0) * PEAK_DECAY);
-        (state.recentCallMs ??= []).push(latencyMs);
-        if (state.recentCallMs.length > CYCLE_RING_SIZE)
-            state.recentCallMs.shift();
-    }
-    if (latencyMs > 0 && outputTokens > 0) {
-        const tps = (outputTokens / latencyMs) * 1000;
-        state.emaTokPerSec =
-            state.emaTokPerSec === undefined ? tps : EWMA_ALPHA * tps + (1 - EWMA_ALPHA) * state.emaTokPerSec;
-    }
-}
-export function recordTtftSample(state, ttftMs) {
-    if (Number.isFinite(ttftMs) && ttftMs >= 0) {
-        state.ttftEwma = state.ttftEwma === undefined ? ttftMs : EWMA_ALPHA * ttftMs + (1 - EWMA_ALPHA) * state.ttftEwma;
-    }
-}
-export function recordToolSample(state, durationMs) {
-    if (durationMs > 0) {
-        state.emaToolMs = state.emaToolMs === undefined ? durationMs : EWMA_ALPHA * durationMs + (1 - EWMA_ALPHA) * state.emaToolMs;
-        state.peakToolMs = Math.max(durationMs, (state.peakToolMs ?? 0) * PEAK_DECAY);
-    }
-}
-export function recordToolCycleSample(state, wallSpanMs) {
-    if (wallSpanMs > 0) {
-        (state.recentToolMs ??= []).push(wallSpanMs);
-        if (state.recentToolMs.length > CYCLE_RING_SIZE)
-            state.recentToolMs.shift();
-    }
-}
-export function computeCallCap(ref, nowMs, thinkingActive) {
-    const staticCapTokens = ref.staticCapTokens;
-    const deadline = ref.deadlineMs;
-    if (deadline === undefined)
-        return undefined;
-    const remainingMs = deadline - nowMs;
-    if (remainingMs <= 0)
-        return undefined;
-    const tokPerSec = ref.state.emaTokPerSec ?? CALL_CAP_PRIOR_TOK_PER_SEC;
-    const raw = Math.floor((remainingMs / 1000) * tokPerSec * CALL_CAP_SAFETY);
-    const floor = ref.finalizeMode ? CALL_CAP_THINKING_MIN : CALL_CAP_MIN_FLOOR;
-    let cap = Math.max(floor, raw);
-    let thinkingSkipped = false;
-    if (thinkingActive && cap < CALL_CAP_THINKING_MIN) {
-        if ((remainingMs / 1000) * tokPerSec >= CALL_CAP_THINKING_MIN) {
-            cap = CALL_CAP_THINKING_MIN;
-        }
-        else {
-            thinkingSkipped = true;
-        }
-    }
-    if (staticCapTokens !== undefined && staticCapTokens > 0 && cap >= staticCapTokens) {
-        ref.state.last = undefined;
-        return undefined;
-    }
-    ref.state.last = { cap, remainingMs, tokPerSec: Math.round(tokPerSec * 10) / 10, thinkingSkipped };
-    return cap;
-}
-export function estimateCycleMs(state) {
-    if (state.recentCallMs === undefined || state.recentCallMs.length === 0)
-        return Math.ceil(FINALIZE_PRIOR_CYCLE_MS * FINALIZE_HEADROOM);
-    const p75 = (ring) => {
-        if (ring === undefined || ring.length === 0)
-            return 0;
-        const sorted = [...ring].sort((a, b) => a - b);
-        return sorted[Math.max(0, Math.ceil(sorted.length * CYCLE_PERCENTILE) - 1)];
-    };
-    const clampMs = state.recentCallMs.length < 3 ? FINALIZE_PRIOR_CYCLE_MS : Number.POSITIVE_INFINITY;
-    return Math.ceil((Math.min(p75(state.recentCallMs), clampMs) + Math.min(p75(state.recentToolMs), clampMs)) * FINALIZE_HEADROOM);
-}

package/dist/core/runner/cut-kill.d.ts

@@ -1,10 +0,0 @@
-export interface ExecKillHandle {
-    pid: number;
-    kill: () => void;
-}
-export interface CutKillRegistry {
-    register: (toolCallId: string, handle: ExecKillHandle) => () => void;
-    killFor: (toolCallId: string) => number;
-    kills: number;
-}
-export declare function createCutKillRegistry(): CutKillRegistry;

package/dist/core/runner/cut-kill.js

@@ -1,37 +0,0 @@
-export function createCutKillRegistry() {
-    const live = new Map();
-    const registry = {
-        kills: 0,
-        register: (toolCallId, handle) => {
-            let set = live.get(toolCallId);
-            if (!set) {
-                set = new Set();
-                live.set(toolCallId, set);
-            }
-            set.add(handle);
-            return () => {
-                set.delete(handle);
-                if (set.size === 0)
-                    live.delete(toolCallId);
-            };
-        },
-        killFor: (toolCallId) => {
-            const set = live.get(toolCallId);
-            if (!set || set.size === 0)
-                return 0;
-            let signalled = 0;
-            for (const h of set) {
-                try {
-                    h.kill();
-                    signalled++;
-                }
-                catch {
-                }
-            }
-            if (signalled > 0)
-                registry.kills += 1;
-            return signalled;
-        },
-    };
-    return registry;
-}