@sema-agent/core/dist/core/delegation-frames.js

Stateless, task-oriented AI agent core

import { observeThenableRejection } from "./safe-notify.js";
export function backgroundChildTerminal(completion, row) {
    const seq = completion.seq ?? row.generation;
    const usage = fleetUsageOf(completion.usage);
    return {
        kind: "terminal",
        taskId: row.taskId,
        sessionScoped: row.sessionScoped,
        ...(row.sessionId !== undefined ? { sessionId: row.sessionId } : {}),
        ...(row.transcriptId !== undefined ? { transcriptId: row.transcriptId } : {}),
        ...(row.parentToolCallId !== undefined ? { parentToolCallId: row.parentToolCallId } : {}),
        status: completion.status,
        ...(seq !== undefined ? { seq } : {}),
        ...(completion.stoppedBy !== undefined ? { stoppedBy: completion.stoppedBy } : {}),
        summary: completion.summary,
        ...(completion.result !== undefined ? { result: completion.result } : {}),
        ...(completion.recentSteps !== undefined ? { recentSteps: completion.recentSteps } : {}),
        ...(completion.editedFiles !== undefined ? { editedFiles: completion.editedFiles } : {}),
        ...(completion.resumable !== undefined ? { resumable: completion.resumable } : {}),
        ...(usage !== undefined ? { usage } : {}),
        ...(completion.completionId !== undefined ? { completionId: completion.completionId } : {}),
    };
}
function fleetUsageOf(usage) {
    if (typeof usage !== "object" || usage === null)
        return undefined;
    const u = usage;
    return {
        ...(typeof u.tokens === "number" ? { tokens: u.tokens } : {}),
        ...(typeof u.turns === "number" ? { turns: u.turns } : {}),
        ...(typeof u.costMicroUsd === "number" ? { costMicroUsd: u.costMicroUsd } : {}),
        ...(typeof u.tool_uses === "number" ? { toolUses: u.tool_uses } : {}),
        ...(typeof u.duration_ms === "number" ? { durationMs: u.duration_ms } : {}),
    };
}
export function emitsChildRowFrames(identity) {
    return identity.isDelegatedChild;
}
export function taskStartedFrame(run, spawner, stamp) {
    const { identity } = run;
    return {
        type: "task_started",
        taskId: run.taskId,
        sessionId: run.sessionId,
        ...(spawner?.delegationTaskType !== undefined ? { taskType: spawner.delegationTaskType } : {}),
        ...(spawner?.cycleSeq !== undefined ? { seq: spawner.cycleSeq } : {}),
        ...(spawner?.parentTaskId !== undefined ? { parentTaskId: spawner.parentTaskId } : {}),
        ...(spawner?.parentSessionId !== undefined ? { parentSessionId: spawner.parentSessionId } : {}),
        ...(spawner?.rootSessionId !== undefined ? { rootSessionId: spawner.rootSessionId } : {}),
        ...(identity.agentName ? { name: identity.agentName } : {}),
        ...(spawner?.explicitAgentName !== undefined ? { spawnName: spawner.explicitAgentName } : {}),
        ...(spawner?.spawnAgentType !== undefined ? { agentType: spawner.spawnAgentType } : {}),
        model: run.model,
        startedAt: Date.now(),
        ...stamp,
    };
}
let malformedDelegationSeatAnnounced = false;
export function __resetMalformedDelegationSeatAnnouncement() {
    malformedDelegationSeatAnnounced = false;
}
export function deliverDelegationLifecycle(seat, event, notifier, site) {
    if (typeof seat === "function") {
        const frame = Object.freeze(Object.assign(Object.create(null), event));
        notifier.notify(() => observeThenableRejection(seat(frame), notifier, site), site);
        return;
    }
    if (seat !== undefined && !malformedDelegationSeatAnnounced) {
        malformedDelegationSeatAnnounced = true;
        try {
            console.warn(`The delegation-lifecycle sink (RunnerDeps.onDelegationLifecycle) holds ${seat === null ? "null" : typeof seat} — not a ` +
                `function. Delegation spawn/terminal frames are NOT delivered until the wiring is fixed (omit the key, or wire a function).`);
        }
        catch {
        }
    }
}