@sema-agent/core/dist/brain/stream-shared.js

Stateless, task-oriented AI agent core

import { isProviderEchoShape, providerEchoReading } from "./errors.js";
import { inspectDegenerate } from "./repetition.js";
import { emitBrainTelemetry } from "./status-sink.js";
import { stampStreamDrops } from "../internal/llm.js";
export const STREAM_TORN_WARNING = "Connection closed mid-response. The response above may be incomplete.";
export function echoFoldedWord(raw) {
    return isProviderEchoShape(raw) ? raw : "?";
}
export function createStreamEndLedger() {
    let ignored;
    return {
        note(statement, word) {
            ignored = ignored === undefined ? { statement, word: echoFoldedWord(word), frames: 1 } : { ...ignored, frames: ignored.frames + 1 };
        },
        get ignored() {
            return ignored;
        },
    };
}
export function parseStreamedToolArgs(json, closed) {
    if (!json)
        return closed ? {} : undefined;
    let parsed;
    try {
        parsed = JSON.parse(json);
    }
    catch {
        return undefined;
    }
    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
        return undefined;
    return parsed;
}
export function nameMissingCause(closed) {
    return closed ? "unnamed" : "truncated";
}
export function placeTurnNotes(message, content, notes) {
    if (notes.length === 0)
        return;
    const at = content.findIndex((block) => block.type === "toolCall");
    content.splice(at === -1 ? content.length : at, 0, ...notes.map(({ text }) => ({ type: "text", text })));
    stampStreamDrops(message, notes);
}
export function truncationCauseClause(facts) {
    const { capStop, outputTokens, capTokens, terminalFrameSeen } = facts;
    if (capTokens !== undefined && (capStop || (outputTokens !== undefined && outputTokens >= capTokens))) {
        return `; request output cap in effect: ${capTokens} tokens — a cut mid-arguments commonly means the cap was hit`;
    }
    return terminalFrameSeen ? "" : "; the stream ended before its stop frame — the connection closed mid-response";
}
const countOf = (v) => (typeof v === "number" && Number.isInteger(v) && v >= 0 ? v : undefined);
export function modelOutputInvalidOf(drops, cap) {
    if (drops.truncated > 0) {
        const outputTokens = countOf(cap.outputTokens);
        const capTokens = countOf(cap.capTokens);
        return { cause: "truncated", outputLimit: { capStop: cap.capStop, ...(outputTokens !== undefined ? { outputTokens } : {}), ...(capTokens !== undefined ? { capTokens } : {}) } };
    }
    return drops.unnamed > 0 ? { cause: "unnamed" } : undefined;
}
export function createRepetitionPoll() {
    let repCut;
    const repSpared = new Map();
    return {
        get cut() {
            return repCut;
        },
        get spared() {
            return [...repSpared.values()];
        },
        poll(text) {
            const insp = inspectDegenerate(text);
            for (const s of insp.spared) {
                const k = `${s.rule} ${s.segment}`;
                const prev = repSpared.get(k);
                if (prev === undefined)
                    repSpared.set(k, s);
                else if (s.reps > prev.reps)
                    prev.reps = s.reps;
            }
            if (insp.degenerate)
                repCut = insp.cut;
            return insp.degenerate;
        },
    };
}
const refusedModelCounted = new WeakSet();
export function noteResponseModel(partial, reported, requestedId) {
    const reading = providerEchoReading(reported);
    if (reading === "absent")
        return;
    if (reported === requestedId) {
        delete partial.responseModel;
        return;
    }
    if (reading === "refused") {
        if (!refusedModelCounted.has(partial)) {
            refusedModelCounted.add(partial);
            emitBrainTelemetry({ kind: "echo_dropped", field: "responseModel" });
        }
        return;
    }
    partial.responseModel = reported;
}