@sema-agent/core 7.6.3 → 7.8.0

package/dist/core/runner/runtask.d.ts

@@ -3,77 +3,9 @@ import { type CheckpointToken, type ResumeOutcome } from "../checkpoint-store.js
 import { type TaskOutcome } from "../task-outcome.js";
 import { type SideQuerySpec, type SideQueryResult } from "../side-query.js";
 import type { SessionStore } from "../session.js";
-import { type RecoveredOrphan } from "../session-reconcile.js";
-import type { GateOutcome } from "../gate-outcome.js";
-import { type McpDelivered } from "../mcp-failure.js";
 import type { AgentDefinition, ModelRef, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream } from "../types.js";
 import type { ResumeRun, ResumeTaskConfig, RunInternals, RunnerSelfSeat } from "./contracts.js";
 export type { ResumeTaskConfig } from "./contracts.js";
-/** The `tool_end` body fields projected from a harness tool result — output/truncated/totalChars via
- *  {@link toolOutputFrom} and the CC card via {@link structuredFrom}. Single construction point for BOTH
- *  the live loop's frames and the resumed batch's frames (`resolvePendingCall` + the deferred-sibling
- *  close): the resumed frames used to carry only `isError`, so a client rendering tool output from frames
- *  showed an empty body for every durable-approved call. Same projection = same source as the transcript.
- *  Also the one place the gate outcome reaches a frame — see the parameter. */
-declare function toolEndBodyFrom(result: unknown, isError: boolean, 
-/** The gate's record of the pass that admitted or refused this call, supplied by the CALLER of this
- *  projection — the live loop reads it off the gate's per-call sideband, the resumed leg off the decide's
- *  minted record. Deliberately a parameter and never derived from `result`: a tool's own `details`
- *  (which post-tool hooks may also replace) is writable by layers that adjudicate nothing, so reading
- *  provenance out of it would let a failing tool claim a person approved it. Omitted ⇒ the call never
- *  went through the gate (see the `tool_end.gate` doc, the one home). */
-gate?: GateOutcome, 
-/** WHICH call this run's committed durable park is holding ({@link gatedCallIdOf}), for the frames the
- *  abort short-circuits. Same never-derived-from-`result` posture as the outcome above, and for the
- *  sharpest version of that reason: this one is an assertion about a DIFFERENT call, so a tool able to
- *  author it could point an approval UI at a call nobody is waiting on. Omitted ⇒ no park is holding a
- *  call (nothing parked, or the park that did holds none), and the frame then carries no id at all. */
-gatedCallIdOfRun?: string): {
-    output?: unknown;
-    truncated?: boolean;
-    totalChars?: number;
-    structured?: unknown;
-    errorCode?: string;
-    delivered?: McpDelivered;
-    gatedCallId?: string;
-    gate?: GateOutcome;
-};
-/**
- * scan-1/A1 — the BODY of the synthetic `tool_end` that closes a reconcile-recovered orphan. ONE
- * construction point for BOTH minting legs (the live-abort loop at the end of a run, and the wake/crash
- * leg's replay at run open), so the two can never disagree about the shape of the same event.
- *
- * Both frames used to carry `isError:true` and NOTHING else: a consumer rendering tool output from the
- * event stream showed an EMPTY body for every interrupted call, even though the persisted transcript
- * (which the model reads) carried the full `[INTERRUPTED]` explanation — the two faces of one call
- * disagreed. The projection goes through the same {@link toolEndBodyFrom} every live tool result uses, so
- * `output` = the persisted model-facing text and `errorCode` = the persisted `details.errorKind`
- * (`interrupted_never_started` / `interrupted_outcome_unknown`) — a consumer discriminates on the code
- * instead of prose-matching. No `structured`: the reconcile mints no CC card (no `details.type`), which
- * `structuredFrom`'s allowlist already enforces.
- */
-export declare function reconciledToolEndBody(orphan: Pick<RecoveredOrphan, "text" | "errorKind">): ReturnType<typeof toolEndBodyFrom>;
-export declare const GOVERNANCE_READ_STALLED: unique symbol;
-/** Await a ledger charge, firing `onSlow` ONCE if it has not settled after
- *  {@link CHARGE_SETTLE_DISCLOSE_MS}. The charge itself is always awaited to completion. */
-export declare function awaitChargeWithSlowDisclosure<T>(charge: Promise<T>, onSlow: () => void, discloseAfterMs?: number): Promise<T>;
-/**
- * Await `p` until the absolute epoch `deadline`, then give up with {@link GOVERNANCE_READ_STALLED}.
- *
- * Chunked, and deliberately so: the deadline is derived from a caller-declared environment lifetime, so
- * the distance to it can exceed {@link MAX_TIMER_DELAY_MS} — a single timer armed for that distance
- * would fire at once and abandon a perfectly healthy read. Each chunk re-reads the wall clock, so the
- * decision is always made against the deadline itself rather than against an allowance computed once.
- *
- * Exported for its own unit pin (the same posture as the brain-call guardrail primitive): the
- * behaviors below are clock behaviors, and only a virtual clock can assert them without spending the
- * wall-clock time they describe. Not re-exported from the package index.
- *
- * An already-overdue deadline still gets ONE zero-delay pass: a promise that is settled (or settles in a
- * microtask, which is every in-process store) must be allowed to win, because giving up on an answer we
- * already hold would be a fabricated stall. The second pass is what makes the loop terminate.
- */
-export declare function raceUntilDeadline<T>(p: Promise<T>, deadline: number): Promise<T | typeof GOVERNANCE_READ_STALLED>;
 /**
  * A stateless task runner. Holds shared deps (the external brain, model catalog) and an
  * in-memory session store so that passing a `sessionId` continues a prior conversation.