@sema-agent/core 7.54.1 → 7.56.0

package/dist/core/runner/tool-end-body.js

@@ -1,6 +1,6 @@
 import {} from "../../internal/harness.js";
-import { readMember } from "../thrown-value.js";
-import { refusedBeforeRelease } from "./tool-not-executed.js";
+import { isPlainRecord } from "../mods/kernel/receive.js";
+import { neverExecuted } from "./tool-not-executed.js";
 import { MCP_DELIVERY_VERDICTS } from "../mcp-failure.js";
 import { closeNeverExecuted } from "../session-reconcile.js";
 import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
@@ -38,11 +38,12 @@ export function batchResponseDigest(result) {
 export function toolEndBodyFrom(result, isError, leg, gate, gatedCallIdOfRun) {
     const o = toolOutputFrom(result, leg.mediaByteCapBytes);
     const st = leg.structured(result);
-    const det = isError ? readMember(result, "details") : undefined;
-    const codeRaw = readMember(det, "code");
-    const kindRaw = readMember(det, "errorKind");
+    const det = isError ? result?.details : undefined;
+    const card = isPlainRecord(det) ? det : undefined;
+    const codeRaw = card?.code;
+    const kindRaw = card?.errorKind;
     const code = typeof codeRaw === "string" ? codeRaw : typeof kindRaw === "string" ? kindRaw : undefined;
-    const deliveredRaw = readMember(det, "delivered");
+    const deliveredRaw = card?.delivered;
     const delivered = typeof deliveredRaw === "string" && MCP_DELIVERY_VERDICTS.includes(deliveredRaw) ? deliveredRaw : undefined;
     const gatedCallId = code === "gate.parked" ? gatedCallIdOfRun : undefined;
     return {
@@ -54,7 +55,7 @@ export function toolEndBodyFrom(result, isError, leg, gate, gatedCallIdOfRun) {
         ...(gate !== undefined ? { gate } : {}),
     };
 }
-const startFrameOf = (o, recovered) => ({ type: "tool_start", toolCallId: o.toolCallId, toolName: o.spelledName, ...(o.label !== undefined ? { label: o.label } : {}), args: o.args, ...(recovered ? { recovered: true } : {}) });
+const startFrameOf = (o, recovered) => ({ type: "tool_start", toolCallId: o.toolCallId, toolName: o.spelledName, ...(o.label !== undefined ? { label: o.label } : {}), args: o.args, ...(recovered ? { recovered: true } : {}), ...(o.requestedBy !== undefined ? { requestedBy: o.requestedBy } : {}) });
 export function announceToolCall(table, start, frames) {
     table.open(start);
     frames.push(startFrameOf(start, false));
@@ -65,7 +66,7 @@ export function emitSettled(table, start, end, frames) {
     if (!occ.startEmitted)
         frames.push(startFrameOf(occ, true));
     const gate = occ.gateRounds.at(-1);
-    const isError = end.isError || gate?.disposition.kind === "denied", notExecuted = end.notExecuted === true || refusedBeforeRelease(occ);
+    const isError = end.isError || gate?.disposition.kind === "denied", notExecuted = end.notExecuted === true || neverExecuted(occ);
     table.close(occ.toolCallId, end.interrupted === true ? "interrupted" : "settled");
     frames.push({
         type: "tool_end",
@@ -75,7 +76,7 @@ export function emitSettled(table, start, end, frames) {
         isError,
         ...toolEndBodyFrom(end.result, isError, frames, gate, end.gatedCallIdOfRun),
         ...(gate?.disposition.kind === "denied" && occ.wireName !== undefined ? { wireName: occ.wireName } : {}),
-        ...(notExecuted ? { notExecuted: true } : {}),
+        ...(notExecuted ? { notExecuted: true } : {}), ...(occ.answeredInPlaceBy !== undefined ? { answeredBy: occ.answeredInPlaceBy } : {}), ...(occ.requestedBy !== undefined ? { requestedBy: occ.requestedBy } : {}),
     });
     return { ...(gate !== undefined ? { gate } : {}), isError, ...(notExecuted ? { notExecuted: true } : {}) };
 }

package/dist/core/runner/tool-face-overlay.d.ts

@@ -2,7 +2,8 @@
  * The MCP `toolFaces` OVERLAY: a deployment's per-tool face declaration for a
  * protocol tool that has no `ToolSpec` of its own (`McpServerSpec.toolFaces`, keyed by the server's RAW
  * tool name like `allowTools` / `toolAxes`). Validated against the MATERIALIZED schema at every listing
- * (the first mount and every RefreshMcpTools): `pathTarget.param` must be a top-level property; an
+ * (the first mount and every RefreshMcpTools): `pathTarget.param` / `hostTarget.param` must be a top-level property (and a
+ * face declares at most one of the two); an
  * `approvalCard` must find the keys the card needs; a `ruleFace` may only name scalar keys; `family`
  * must be a member of the closed set; every `resultCards` entry must live under the tool's own card namespace.
  * A failing overlay does NOT mount — the tool mounts BARE (no

package/dist/core/runner/tool-face-overlay.js

@@ -2,7 +2,7 @@ import { MCP_NAMESPACE } from "../protocol-table.js";
 import { mintNamespacePrefix } from "../protocol-naming.js";
 import { RESERVED_APPROVAL_CARDS, TOOL_APPROVAL_CARDS, TOOL_FAMILIES, TOOL_PATH_ABSENCES, TOOL_PATH_ACCESSES, TOOL_PATH_BASES, RENDER_HINT_ACTIVITY_MAX_CHARS, RENDER_HINT_MAX_CHARS, RENDER_HINT_MAX_LIST, TOOL_KEY_MAX_CHARS, } from "../tool-face.js";
 import { engineCardOf, inputKeysOf, offendingResultCard, protocolToolOf, rosterCardId } from "../tool-roster.js";
-import { engineCardTypes } from "../tool-registry.js";
+import { engineCardTypes, hostTargetingToolNames } from "../tool-registry.js";
 import { deliverEngineNotice } from "../engine-notice.js";
 export const APPROVAL_CARD_REQUIRED_KEYS = Object.freeze({
     "file-edit": ["file_path"],
@@ -10,6 +10,8 @@ export const APPROVAL_CARD_REQUIRED_KEYS = Object.freeze({
     "notebook-edit": ["notebook_path"],
     shell: ["command"],
     fetch: ["url"],
+    skill: ["skill"],
+    workflow: [],
     plan: [],
     question: [],
     generic: [],
@@ -58,6 +60,19 @@ export function faceProblem(face, schema, tool) {
         for (const a of face.pathTarget.aliases ?? [])
             vocabulary.add(a);
     }
+    if (face.hostTarget !== undefined) {
+        const hostNames = hostTargetingToolNames();
+        if (tool === undefined || !hostNames.has(tool.toolName)) {
+            return `hostTarget is declared on a tool whose name host rules are not written for (they are written for ${[...hostNames].join(", ")}) — a host rule's grammar belongs to the rule's tool name, so the slot would never be read; declare it only on a tool of that name`;
+        }
+        if (face.pathTarget !== undefined)
+            return `hostTarget and pathTarget are both declared — a face names one protected target, the URL a call reaches or the path it touches`;
+        if (top !== undefined && (typeof face.hostTarget.param !== "string" || !top.has(face.hostTarget.param)))
+            return `hostTarget.param ${JSON.stringify(face.hostTarget.param)} is not a top-level property of the tool's schema`;
+        const long = overlong("hostTarget.param", [face.hostTarget.param]);
+        if (long !== undefined)
+            return long;
+    }
     const hints = face.renderHints;
     if (hints !== undefined) {
         const card = hints.approvalCard;
@@ -148,6 +163,7 @@ export function applyMcpToolFaces(input) {
             ...t,
             ...(f.family !== undefined ? { family: f.family } : {}),
             ...(f.pathTarget !== undefined ? { pathTarget: f.pathTarget } : {}),
+            ...(f.hostTarget !== undefined ? { hostTarget: f.hostTarget } : {}),
             ...(f.renderHints !== undefined ? { renderHints: f.renderHints } : {}),
             ...(f.ruleFace !== undefined ? { ruleFace: f.ruleFace } : {}),
         };

package/dist/core/runner/tool-not-executed.d.ts

@@ -4,9 +4,14 @@ import type { ToolOccurrence } from "./tool-occurrence.js";
  *  release, by a station inside the execution, is not). A call whose start this stream never carried (a recovered
  *  one, closed by a station that knows only its own class) is not read here. */
 export declare function refusedBeforeRelease(occ: Pick<ToolOccurrence, "life" | "gateRounds" | "startEmitted">): boolean;
+/** The one reading of the engine's positive evidence that a call never ran: refused before it was let go
+ *  ({@link refusedBeforeRelease}), or answered in place of its body by an extension at `tool.call` (the body was never called). */
+export declare function neverExecuted(occ: Pick<ToolOccurrence, "life" | "gateRounds" | "startEmitted" | "answeredInPlaceBy">): boolean;
 /** `details` as a persisted `toolResult` row carries it: `notExecuted` is the ENGINE's key — the settlement's fact when it holds,
  *  absent otherwise, whatever a tool wrote under that name. Returns `details` itself unless the key has to move; never mutates it. */
 export declare function rowDetailsOf(details: unknown, notExecuted: boolean): unknown;
+/** The persisted row's mark: the call this `toolResult` row closes never ran (the key {@link rowDetailsOf} writes). */
+export declare function rowNotExecuted(details: unknown): boolean;
 /** A row the resumed leg mints (`toolResultMsg`) with the settlement's fact on it. */
 export declare function withRowNotExecuted<T extends object>(row: T, notExecuted: boolean): T;
 /** Write the end projection's one `notExecuted` onto the result the live loop persists as the call's row: the loop builds that message

package/dist/core/runner/tool-not-executed.js

@@ -2,6 +2,9 @@ import { readOwnMembers } from "../thrown-value.js";
 export function refusedBeforeRelease(occ) {
     return occ.life === "announced" && occ.startEmitted && occ.gateRounds.at(-1)?.disposition.kind === "denied";
 }
+export function neverExecuted(occ) {
+    return refusedBeforeRelease(occ) || occ.answeredInPlaceBy !== undefined;
+}
 export function rowDetailsOf(details, notExecuted) {
     const carries = (() => { try {
         return details !== null && typeof details === "object" && !Array.isArray(details) && Object.keys(details).includes("notExecuted");
@@ -18,6 +21,14 @@ export function rowDetailsOf(details, notExecuted) {
         delete bag["notExecuted"];
     return bag;
 }
+export function rowNotExecuted(details) {
+    try {
+        return details !== null && typeof details === "object" && details.notExecuted === true;
+    }
+    catch {
+        return false;
+    }
+}
 export function withRowNotExecuted(row, notExecuted) {
     return notExecuted ? { ...row, details: rowDetailsOf(undefined, true) } : row;
 }

package/dist/core/runner/tool-occurrence.d.ts

@@ -42,6 +42,8 @@ export interface OccurrenceStart {
     readonly label?: string;
     /** The arguments the start frame carries (for a recovered start: the call's own input as the transcript holds it). */
     readonly args: unknown;
+    /** An extension's own call (`$.tool.call`): who asked for it — the frames carry it. Absent for a call a model message carried. */
+    readonly requestedBy?: import("../task-event.js").ExtensionRequester;
 }
 /** The record, as its readers see it. Written only through {@link ToolOccurrenceTable}. */
 export interface ToolOccurrence extends OccurrenceStart {
@@ -63,6 +65,9 @@ export interface ToolOccurrence extends OccurrenceStart {
     /** The heartbeat covers it. Cleared when the loop leaves the call behind at a turn end with no end of its own:
      *  the record stays (a later settlement must still know its start frame went out) but no beat describes it. */
     readonly beating: boolean;
+    /** An extension at `tool.call` answered for the call in place of its body — its result, or its refusal — and named here:
+     *  the body was never called (positive evidence the call did not run). Absent: no station answered in its place. */
+    readonly answeredInPlaceBy?: string;
 }
 /** The table of one leg's occurrences — the record's only writer. */
 export interface ToolOccurrenceTable {
@@ -86,6 +91,9 @@ export interface ToolOccurrenceTable {
     /** A station after the gate refused the call: one more gate record, minted as a veto of whatever the latest one
      *  settled (a person's yes stays on the settlement; the refusing layer is the disposition). Returns the record. */
     refuse(toolCallId: string, layer: DeniedBy): GateOutcome;
+    /** An extension at `tool.call` answered for the call before its body was called (the kernel's record says the body had
+     *  not started): the body is never called for this attempt. Once per attempt; a second is an engine defect. */
+    answeredInPlace(toolCallId: string, by: string): void;
     /** An ask for this call is put to the person: the count rises, and the returned `resumeFromUser` lowers it once
      *  (a second call is a no-op). The pair is bound to THIS attempt — a return after the call ended, or after a
      *  reused id re-opened, touches nothing — and an ask for a call this leg does not hold counts nothing: the wait

package/dist/core/runner/tool-occurrence.js

@@ -21,6 +21,7 @@ export function createToolOccurrenceTable() {
             ...(start.wireName !== undefined ? { wireName: start.wireName } : {}),
             ...(start.label !== undefined ? { label: start.label } : {}),
             args: start.args,
+            ...(start.requestedBy !== undefined ? { requestedBy: start.requestedBy } : {}),
             attempt,
             life: "announced",
             awaitingUser: 0,
@@ -96,6 +97,12 @@ export function createToolOccurrenceTable() {
             occ.gateRounds.push(round);
             return round;
         },
+        answeredInPlace(toolCallId, by) {
+            const occ = held(toolCallId, "an answer in place of the body");
+            if (occ.answeredInPlaceBy !== undefined)
+                throw new Error(`tool occurrence: call "${toolCallId}" (attempt ${occ.attempt}) was already answered in place`);
+            occ.answeredInPlaceBy = by;
+        },
         heard(toolCallId) {
             const occ = byId.get(toolCallId);
             if (occ !== undefined)

package/dist/core/runner/tool-progress-lane.d.ts

@@ -37,8 +37,8 @@
 import type { TaskEvent, TaskEventIdentity } from "../types.js";
 import type { ToolProgressLane } from "./contracts.js";
 import { type ToolOccurrenceTable } from "./tool-occurrence.js";
-/** How long a tool call may stay silent before this lane beats for it, in ms. ONE SOURCE, and CC
- *  2.1.259's own per-tool heartbeat interval (`Cct`) — this engine keeps the cadence and folds the beat
+/** How long a tool call may stay silent before this lane beats for it, in ms. ONE SOURCE, and the reference's
+ *  own per-tool heartbeat interval — this engine keeps the cadence and folds the beat
  *  into the one progress frame instead of minting a second shape (registered divergence). */
 export declare const TOOL_HEARTBEAT_MS = 30000;
 /** The floor between two frames of ONE call — the `tool_progress.cadence` contract, enforced here and

package/dist/core/runner/tool-turn-repair-seat.d.ts

@@ -26,8 +26,9 @@ export type ToolTurnIncompleteItem = {
     count: number;
     toolCallIds: readonly string[];
 };
-/** Does a turn's content carry a tool call? A tool-calling turn GUARANTEES a next request (its results go back to the
- *  model): the engine's one continuation fact — the harness's boundary gates and the dropped-call line read it here. */
+/** Does a turn's content carry a tool call? The dropped-call line's reading of "the turn goes on", taken at the message's
+ *  end before its batch runs. The turn boundary does not read it: whether the turn owes the next request is the loop's
+ *  own decision (a batch can end the run), handed to the boundary as `continues`. */
 export declare function turnCarriesToolCall(content: unknown): boolean;
 /** The person's line for one cause — once per run per cause, whichever observer saw it first. */
 export interface ToolTurnIncompleteSeat {