@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/adapter/runStream.js

@@ -1,20 +1,23 @@
-import { eventSeq, stamp, } from './types.js';
+import { eventSeq, isSubFlowSegmentEnd, SEGMENT_END_IDENTITY_KEYS, snapshotIsSubFlow, stamp, } from './types.js';
 import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.js';
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
-import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
+import { terminalPartsOfObserved, readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.js';
 import { publishSubagentContentEvent, subagentContentEventOf } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { doneResultView, isReplayedTerminal } from '../replayBody.js';
-import { readFrameStringKey } from '../ownKey.js';
+import { carriesAnswerText, guardedRead, readFrameStringKey } from '../ownKey.js';
+import { ccErrorOfProviderStatus } from '../providerRejection.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { abortCauseNoteOf } from '../runCancelContext.js';
-import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
-import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
+import { classifyToolHistoryMismatch, noteToolHistoryTerminalFacts, SEMA_TOOL_HISTORY_ACCEPTED_KEY, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
+import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalCodedDetail } from '../runTerminal.js';
 import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { providerRejectionResend } from '../providerRejection.js';
 import { displayUntrusted, washCredentials } from '../displayUntrusted.js';
-import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
+import { runBlockedText } from '../promptBlockedCopy.js';
+import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX, SESSION_BUSY_ROW_LEAD, legacyRowKindOfText, } from '../rowKind.js';
+export { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX };
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
@@ -109,22 +112,17 @@ function busyReadOfFrame(ev, doneTerminal, preReadActiveTaskId) {
     const cls = classifyActiveRunBusy({ errorCode: (isDone ? runTerminalCode(terminal) : undefined) ?? flatCode, activeTaskId });
     return { carrier, cls };
 }
-export const RUN_STOPPED_MESSAGE_PREFIX = 'Run stopped';
-export const RUN_BLOCKED_MESSAGE_PREFIX = 'Run blocked';
 export function isGovernanceStopRowText(text) {
-    const t = text.trimStart();
-    return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`) || t.startsWith(PROMPT_BLOCKED_BY_HOOK_ROW_LEAD);
+    return legacyRowKindOfText(text) === 'governance_stop';
 }
-export const MODEL_OUTPUT_ERROR_PREFIX = 'Model output error';
 export function isModelOutputErrorText(text) {
     const anchors = ['tool call argument(s) not valid JSON', 'tool call(s) arrived with no tool name and cannot be executed'];
     const t = text.trimStart();
     return anchors.some((a) => t.startsWith(a));
 }
 export function isModelOutputErrorRowText(text) {
-    return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
+    return legacyRowKindOfText(text) === 'model_output_error';
 }
-export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
 function apiErrorRowBitsOf(read) {
     try {
         const status = read.carrier.status;
@@ -134,6 +132,7 @@ function apiErrorRowBitsOf(read) {
             ...(typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 999 ? { status } : {}),
             ...(providerCondition !== undefined ? { providerCondition } : {}),
             ...(errorCode !== undefined ? { errorCode } : {}),
+            ...(read.coded !== undefined ? { codedDetail: read.coded } : {}),
         };
         return Object.keys(bits).length > 0 ? bits : undefined;
     }
@@ -141,7 +140,23 @@ function apiErrorRowBitsOf(read) {
         return undefined;
     }
 }
-function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend, apiError, owner) {
+function wayOutFactsOfApiError(read) {
+    try {
+        const bits = apiErrorRowBitsOf(read);
+        const route = read.detail !== undefined && ownDataBit(read.detail, 'kind') === PROVIDER_REJECTED_DETAIL ? plainObjectOf(ownDataBit(read.detail, 'route')) : undefined;
+        const credentialSource = route === undefined ? undefined : nonEmptyStr(ownDataBit(route, 'credentialSource'));
+        return {
+            ...(bits?.status !== undefined ? { status: bits.status } : {}),
+            ...(bits?.providerCondition !== undefined ? { providerCondition: bits.providerCondition } : {}),
+            ...(credentialSource !== undefined ? { credentialSource } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function syntheticTerminalRow(ctx, identity, replayed, kind, text, historyKey, resend, apiError, owner) {
+    const ccError = kind === 'api_error' && apiError?.status !== undefined ? ccErrorOfProviderStatus(apiError.status) : undefined;
     return stamp(ctx, {
         uuid: identity.runId === undefined ? undefined : terminalUuidOf(identity.runId, identity.label),
         session_id: undefined,
@@ -154,6 +169,9 @@ function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend,
         ...(apiError?.status !== undefined ? { _sema_api_error_status: apiError.status } : {}),
         ...(apiError?.providerCondition !== undefined ? { _sema_provider_condition: apiError.providerCondition } : {}),
         ...(apiError?.errorCode !== undefined ? { _sema_api_error_code: apiError.errorCode } : {}),
+        ...(apiError?.codedDetail !== undefined ? { _sema_coded_detail: apiError.codedDetail } : {}),
+        _sema_row_kind: kind,
+        ...(ccError !== undefined ? { error: ccError } : {}),
         ...(replayed ? { _sema_replay: true } : {}),
         ...(owner !== undefined ? { _sema_terminal_owner: owner } : {}),
     });
@@ -161,11 +179,14 @@ function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend,
 function withTerminalOwner(frame, owner) {
     return owner === undefined ? frame : { ...frame, _sema_terminal_owner: owner };
 }
+function withHistoryAccepted(frame, accepted) {
+    return accepted === undefined ? frame : { ...frame, [SEMA_TOOL_HISTORY_ACCEPTED_KEY]: true };
+}
 function terminalOwnerOfStream(ctx, busy, busyHandle, runId) {
     const hostString = (k) => {
         try {
             const d = Object.getOwnPropertyDescriptor(ctx, k);
-            return d !== undefined && 'value' in d && typeof d.value === 'string' && d.value.length > 0 ? d.value : undefined;
+            return d !== undefined && Object.hasOwn(d, 'value') && typeof d.value === 'string' && d.value.length > 0 ? d.value : undefined;
         }
         catch {
             return undefined;
@@ -192,7 +213,7 @@ function engineSessionIdOf(result) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
 export function isOutcomeUnknownRowText(text) {
-    return text.trimStart().startsWith(`${OUTCOME_UNKNOWN_ROW_PREFIX}:`);
+    return legacyRowKindOfText(text) === 'outcome_unknown';
 }
 export function isGovernanceTerminal(input) {
     if (input.status === 'blocked')
@@ -291,8 +312,18 @@ function ownTerminalSnapshot(result) {
     }
     const ts = ownDataCopy(t, ['kind', 'code', 'message']);
     const detail = plainObjectOf(ownDataBit(t, 'detail'));
-    if (detail !== undefined)
-        ts.detail = ownDataCopy(detail, ['kind', 'status', 'code', 'providerCondition']);
+    if (detail !== undefined) {
+        const detailCopy = ownDataCopy(detail, ['kind', 'status', 'code', 'providerCondition']);
+        const route = plainObjectOf(ownDataBit(detail, 'route'));
+        if (route !== undefined)
+            detailCopy.route = ownDataCopy(route, ['credentialSource', 'root']);
+        if (detailCopy.kind === 'coded') {
+            const body = ownDataBit(detail, 'detail');
+            if (body !== undefined)
+                detailCopy.detail = body;
+        }
+        ts.detail = detailCopy;
+    }
     snap.terminal = ts;
     return snap;
 }
@@ -356,6 +387,7 @@ function apiErrorTerminalFromFacts(x, facts) {
         return {
             carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(read, 'code')), status, nonEmptyStr(ownDataBit(read, 'message'))),
             detail: detail,
+            coded: runTerminalCodedDetail(read),
         };
     }
     catch {
@@ -413,6 +445,15 @@ export function _resetDroppedFrameReportForTest() {
 export function _droppedFrameMemoSizeForTest() {
     return reportedDroppedTypes.size;
 }
+function wireFrameIsSubFlow(ev) {
+    const snap = guardedRead(() => {
+        const s = {};
+        for (const k of SEGMENT_END_IDENTITY_KEYS)
+            s[k] = ev[k];
+        return s;
+    });
+    return snap === undefined || snapshotIsSubFlow(snap);
+}
 function withStringFailureFields(ev) {
     if (ev.type !== 'failed')
         return ev;
@@ -460,6 +501,73 @@ async function* runStreamInner(events, ctx, handle = {}) {
     let deniedCallsOverflowed = false;
     let successfulToolEndObserved = false;
     let streamSawRunOpen = false;
+    const observedSnapshot = () => ({
+        usageMissingObserved,
+        nestedUsageByTask,
+        toolInputByCallId,
+        gateDeniedByByCallId,
+        denialKindByCallId,
+        successfulToolEndObserved,
+        streamSawRunOpen,
+        deniedToolNameByCallId,
+        deniedCallsOverflowed,
+    });
+    handle.observedTerminalParts = () => terminalPartsOfObserved(observedSnapshot());
+    let lastTranscriptRow = null;
+    let liveTailDone = '';
+    let liveTailOpen = '';
+    let liveTailPrev = '';
+    let lateEndDone = '';
+    let lateEndOpen = '';
+    const closeLiveMessage = () => {
+        const t = liveTailDone + liveTailOpen;
+        if (carriesAnswerText(t)) {
+            liveTailPrev = t;
+            lateEndDone = liveTailDone;
+            lateEndOpen = liveTailOpen;
+        }
+        liveTailDone = '';
+        liveTailOpen = '';
+    };
+    const noteRow = (m, wireSubFlow) => {
+        const r = m;
+        if (r.parent_tool_use_id !== null && r.parent_tool_use_id !== undefined)
+            return m;
+        if (isSubFlowSegmentEnd(m))
+            return m;
+        if (wireSubFlow === true)
+            return m;
+        if (r.type === 'assistant' || r.type === 'user') {
+            lastTranscriptRow = m;
+            liveTailDone = '';
+            liveTailOpen = '';
+            liveTailPrev = '';
+            lateEndDone = '';
+            lateEndOpen = '';
+        }
+        else if (r.type === 'stream_event' && r.event?.type === 'text_delta' && typeof r.event.delta === 'string') {
+            liveTailOpen += r.event.delta;
+            if (r.event.delta.length > 0)
+                lateEndOpen = '';
+        }
+        else if (r.type === 'text_end' && typeof r.content === 'string') {
+            if (liveTailDone === '' && liveTailOpen === '' && lateEndOpen !== '') {
+                lateEndDone += r.content;
+                lateEndOpen = '';
+                liveTailPrev = lateEndDone;
+            }
+            else {
+                liveTailDone += r.content;
+                liveTailOpen = '';
+            }
+        }
+        return m;
+    };
+    const lastRowForResult = () => {
+        const open = liveTailDone + liveTailOpen;
+        const tail = carriesAnswerText(open) ? open : liveTailPrev;
+        return carriesAnswerText(tail) ? { type: 'assistant', message: { content: [{ type: 'text', text: tail }] } } : lastTranscriptRow;
+    };
     const sameArgs = (a, b) => {
         if (a === b)
             return true;
@@ -472,6 +580,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
     };
     for await (const rawEv of events) {
         const ev = withStringFailureFields(rawEv);
+        const wireSubFlow = wireFrameIsSubFlow(ev);
         if (ev.type === 'tool_end' && ev.isError !== true)
             successfulToolEndObserved = true;
         const seq = eventSeq(ev);
@@ -596,10 +705,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 reportDroppedFrame('turn_end_usage_absent', ev.type, ctx);
                 continue;
             }
-            const identityEnvelope = ev;
-            const isSubFlow = identityEnvelope.parentToolCallId !== undefined ||
-                identityEnvelope.sourceTaskId !== undefined ||
-                identityEnvelope.bgAgentId !== undefined;
+            const isSubFlow = wireSubFlow;
             {
                 if (measured !== undefined) {
                     handle.latestUsage = usage;
@@ -664,6 +770,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             }
             const outputTokens = engineUsage.outputTokens;
             if (!isSubFlow) {
+                closeLiveMessage();
                 yield {
                     type: 'turn_usage',
                     ...(usageMissing ? { _sema_usage_missing: true } : { _sema_last_assistant_usage: usage }),
@@ -682,7 +789,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
             const terminalRunId = terminalRunIdOf(ev);
             const replayed = isReplayedTerminal(ev);
             const owner = terminalOwnerOfStream(ctx, rowFacts.busy.busy, rowFacts.busy.handle, terminalRunId);
+            let wayOutFacts;
+            let codedDetailJudged;
             const errText = rowFacts.errText;
+            let historyAcceptedSinceMismatch;
             if (errText) {
                 const busy = rowFacts.busy;
                 const maxTokHint = /max_tokens/i.test(errText)
@@ -691,9 +801,11 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 const busyHandle = busy.handle;
                 const arm = terminalRowArmOf(rowFacts);
                 const rowText = arm === 'busy'
-                    ? `This session is locked by an earlier run${busyHandle ? ` (run ${busyHandle})` : ''} that ` +
+                    ? `${SESSION_BUSY_ROW_LEAD}${busyHandle ? ` (run ${busyHandle})` : ''} that ` +
                         `has not been released, so this message was NOT sent. Nothing releases it on its own — ` +
-                        `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
+                        (ctx.lane === 'print' || ctx.lane === 'utility'
+                            ? `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
+                            : `end ${busyHandle ? `run ${busyHandle}` : 'that run'} on the engine, or start a new session.`)
                     : arm === 'governance'
                         ?
                             `${isGovernanceStopRowText(errText) ? errText : `${RUN_STOPPED_MESSAGE_PREFIX}: ${errText}`}${maxTokHint}`
@@ -706,34 +818,40 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     : doneTerminal?.kind === 'failed' && isCorruptSessionCode(doneTerminal.code);
                 const abortNote = abortCauseNoteOf(ev);
                 const historyTerminal = apiErrorTerminalOfRowFrame(ev, rowFacts);
+                if (arm === 'apiError') {
+                    wayOutFacts = wayOutFactsOfApiError(historyTerminal);
+                    codedDetailJudged = { value: historyTerminal.coded };
+                }
                 const historyMismatch = classifyToolHistoryMismatch(historyTerminal.carrier);
                 const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
-                const historyRepeat = noteToolHistoryTerminal({
+                const historyRepeat = noteToolHistoryTerminalFacts({
                     sessionId: historyEchoedSid ?? ctx.sessionId,
                     sessionEchoed: historyEchoedSid !== undefined,
                     generation: historyGeneration,
                     runId: terminalRunId,
                     replay: replayed,
                     mismatch: historyMismatch,
-                });
+                    accepted: false,
+                }).consecutive;
                 const rewindOffered = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind);
                 const rewindLine = rewindOffered
                     ? `\n${TOOL_HISTORY_REWIND_SENTENCE}${historyRepeat !== undefined && historyRepeat >= 2 ? ` ${toolHistoryRepeatSentence(historyRepeat)}` : ''}`
                     : '';
                 const resend = historyTerminal.detail !== undefined ? providerRejectionResend(historyTerminal.detail, historyTerminal.carrier) : undefined;
                 const resendLine = resend !== undefined ? `\n${resend.text}` : '';
-                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'terminal-row' }, replayed, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend, arm === 'apiError' ? apiErrorRowBitsOf(historyTerminal) : undefined, owner);
+                yield noteRow(syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'terminal-row' }, replayed, arm === 'busy' ? 'session_busy' : arm === 'governance' ? 'governance_stop' : arm === 'modelOutput' ? 'model_output_error' : 'api_error', `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend, arm === 'apiError' ? apiErrorRowBitsOf(historyTerminal) : undefined, owner));
             }
             else {
                 const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
-                noteToolHistoryTerminal({
+                historyAcceptedSinceMismatch = noteToolHistoryTerminalFacts({
                     sessionId: echoedSid ?? ctx.sessionId,
                     sessionEchoed: echoedSid !== undefined,
                     generation: historyGeneration,
                     runId: terminalRunId,
                     replay: replayed,
                     mismatch: null,
-                });
+                    accepted: ev.type === 'done' && (doneTerminal?.kind === 'completed' || doneTerminal?.kind === 'paused'),
+                }).acceptedSinceMismatch;
             }
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
@@ -748,23 +866,20 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });
                 }
             }
-            const resultFrame = withTerminalOwner(terminalToSdkResult(ev, ctx, {
-                usageMissingObserved,
-                nestedUsageByTask,
-                toolInputByCallId,
-                gateDeniedByByCallId,
-                denialKindByCallId,
-                successfulToolEndObserved,
-                streamSawRunOpen,
-                deniedToolNameByCallId,
-                deniedCallsOverflowed,
-            }), owner);
+            const mintResultFrame = (lastRow) => withHistoryAccepted(withTerminalOwner(terminalToSdkResult(ev, ctx, {
+                ...observedSnapshot(),
+                wayOutFacts,
+                ...(codedDetailJudged !== undefined ? { codedDetail: codedDetailJudged.value } : {}),
+                lastRow: lastRow,
+            }), owner), historyAcceptedSinceMismatch);
+            let resultFrame = mintResultFrame(lastRowForResult());
             const outcome = resultFrame.
                 _sema_outcome;
             if (outcome === 'unknown') {
-                const errs = resultFrame.errors;
+                const errs = (resultFrame.errors ?? mintResultFrame(null).errors);
                 const sentence = Array.isArray(errs) && typeof errs[0] === 'string' ? errs[0] : 'the run ended without a terminal record this client can read';
-                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`, undefined, undefined, undefined, owner);
+                yield noteRow(syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, 'outcome_unknown', `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`, undefined, undefined, undefined, owner));
+                resultFrame = mintResultFrame(lastRowForResult());
             }
             yield terminalFactOf(ev, doneTerminal);
             yield resultFrame;
@@ -777,7 +892,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
         }
         const projection = eventToSdkMessage(ev, ctx);
         if (projection.kind === 'message') {
-            yield projection.message;
+            yield noteRow(projection.message, wireSubFlow);
             continue;
         }
         if (projection.kind === 'dropped')

package/dist/agentsWireCaps.d.ts

@@ -1,17 +1,12 @@
 import { type EngineProbeOpts, type WireAuthTokenSource } from './engineWireSdk.js';
 import type { ReasoningEffort } from './effortWire.js';
+import type { SkillSpec } from '@sema-agent/sdk';
 import type { ToolRosterView } from './toolRoster.js';
 import { type AssemblyRefusal } from './wireFailureShape.js';
 export declare const MAX_TASK_AGENTS = 32;
 export declare const TASK_AGENT_WIRE_FIELDS: readonly ["name", "whenToUse", "whenToUseLean", "allowTools", "denyTools", "skills", "background", "isolation", "model", "thinking", "systemPrompt", "maxTurns", "memory", "observer", "observerMessage"];
 export type WireThinkingLevel = ReasoningEffort;
-export type TaskAgentWireSkill = {
-    name: string;
-    description: string;
-    content: string;
-    allowedTools?: string[];
-    disallowedTools?: string[];
-};
+export type TaskAgentWireSkill = SkillSpec;
 export declare const AGENT_MEMORY_WORDS: ReadonlySet<string>;
 export type TaskAgentWireMemory = {
     scopes: string[];

package/dist/agentsWireCaps.js

@@ -224,9 +224,8 @@ export function projectAgentsForWire(defs, deps) {
             whoMemo = `agent "${name}"${typeof source === 'string' && source.length > 0 ? ` (${capForDisplay(source, 120)})` : ''}`;
             return whoMemo;
         };
-        const rosterInHand = typeof rosterMountedNames(deps.toolRoster) === 'object';
         const flaws = agentToolListFlaws([item], deps.toolRoster).map((f) => {
-            if (!rosterInHand || f.list !== 'disallowedTools' || f.kind !== 'retired' || f.currentName === undefined || f.toolName !== undefined)
+            if (f.list !== 'disallowedTools' || f.kind !== 'retired' || f.currentName === undefined || f.toolName !== undefined)
                 return f;
             const to = f.currentName;
             if (item.denyTools !== undefined)

package/dist/approvalDecidedByCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectApprovalDecidedByCapability(caps) {
@@ -18,7 +18,7 @@ const reader = createEngineCapReader({
     name: 'approvalDecidedBy',
     project: projectApprovalDecidedByCapability,
 });
-export function observedApprovalDecidedBy(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedApprovalDecidedBy(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function approvalDecidedByAdmitted(reading) {

package/dist/approvalFrameFamilies.d.ts

@@ -0,0 +1,33 @@
+export type ApprovalFrameFamiliesReading = {
+    readonly kind: 'confirmed';
+    readonly families: readonly string[];
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function observedApprovalFrameFamilies(baseUrl?: string | undefined): ApprovalFrameFamiliesReading;
+export type ApprovalFrameFamiliesWithheldCause = 'capability_absent' | 'capability_declined' | 'capability_unreadable' | 'reading_absent';
+export interface ApprovalFrameFamiliesWithheld {
+    readonly cause: ApprovalFrameFamiliesWithheldCause;
+}
+export interface ApprovalFrameFamiliesDeclaration {
+    readonly field: {
+        readonly approvalFrameFamilies?: readonly string[];
+    };
+    readonly withheld?: ApprovalFrameFamiliesWithheld;
+}
+export declare function approvalFrameFamiliesDeclaration(reading: ApprovalFrameFamiliesReading): ApprovalFrameFamiliesDeclaration;
+export declare function frameFamiliesJudgementOf(reading: ApprovalFrameFamiliesReading): FrameFamiliesJudgement;
+export type FrameFamiliesJudgement = {
+    readonly ok: true;
+    readonly families: readonly string[];
+} | {
+    readonly ok: false;
+    readonly cause: ApprovalFrameFamiliesWithheldCause;
+};
+export declare function intersectRenderedFamilies(presented: readonly string[], rendered: readonly string[]): readonly string[];

package/dist/approvalFrameFamilies.js

@@ -0,0 +1,120 @@
+import { engineCapNestedValue, engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { appendOwnElement, guardedRead, readOwnDataValue } from './ownKey.js';
+const PRESENTED_FAMILIES_KEY = 'approvalFrameFamilies';
+const ACCEPTANCE_GROUP_KEY = 'taskSettings';
+const ACCEPTANCE_KEY = 'approvalFrameFamilies';
+const SERVER_FRAME_FAMILY_WORDS = Object.freeze(['tool_approval', 'approval_request']);
+const RENDERED_FRAME_FAMILY_WORDS = Object.freeze(['tool_approval', 'approval_request']);
+const MAX_PRESENTED_ENTRIES = 16;
+const READ_ABSENT = Object.freeze({ kind: 'absent' });
+const READ_DECLINED = Object.freeze({ kind: 'declined' });
+const READ_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const READ_UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+function presentedFamiliesOf(raw) {
+    try {
+        if (!Array.isArray(raw)) {
+            if (typeof raw === 'object' && raw !== null)
+                Object.getPrototypeOf(raw);
+            return 'declined';
+        }
+        const lenDesc = Object.getOwnPropertyDescriptor(raw, 'length');
+        const len = lenDesc !== undefined && Object.hasOwn(lenDesc, 'value') ? lenDesc.value : undefined;
+        if (typeof len !== 'number' || !Number.isInteger(len) || len < 0)
+            return 'unreadable';
+        if (len > MAX_PRESENTED_ENTRIES)
+            return 'declined';
+        const out = [];
+        for (let i = 0; i < len; i++) {
+            const d = Object.getOwnPropertyDescriptor(raw, String(i));
+            if (d === undefined)
+                return 'declined';
+            if (!Object.hasOwn(d, 'value'))
+                return 'unreadable';
+            const w = d.value;
+            if (typeof w !== 'string' || !SERVER_FRAME_FAMILY_WORDS.includes(w))
+                return 'declined';
+            if (!out.includes(w))
+                appendOwnElement(out, w);
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function observedApprovalFrameFamilies(baseUrl) {
+    try {
+        const picked = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
+        const base = typeof picked === 'string' ? picked : undefined;
+        const accepted = engineCapNestedValue(base, ACCEPTANCE_GROUP_KEY, ACCEPTANCE_KEY);
+        switch (accepted.kind) {
+            case 'unobserved':
+                return READ_UNOBSERVED;
+            case 'not_reported':
+                return READ_ABSENT;
+            case 'unreadable':
+                return READ_UNREADABLE;
+            case 'null':
+                return READ_DECLINED;
+            case 'value':
+                if (accepted.value !== true)
+                    return READ_DECLINED;
+                break;
+        }
+        const presented = engineCapValue(base, PRESENTED_FAMILIES_KEY);
+        switch (presented.kind) {
+            case 'unobserved':
+                return READ_UNOBSERVED;
+            case 'not_reported':
+                return READ_ABSENT;
+            case 'unreadable':
+                return READ_UNREADABLE;
+            case 'null':
+                return READ_DECLINED;
+            case 'value': {
+                const families = presentedFamiliesOf(presented.value);
+                if (families === 'declined')
+                    return READ_DECLINED;
+                if (families === 'unreadable')
+                    return READ_UNREADABLE;
+                return Object.freeze({ kind: 'confirmed', families });
+            }
+        }
+    }
+    catch {
+        return READ_UNOBSERVED;
+    }
+}
+const NO_FIELD = Object.freeze(Object.create(null));
+function withheldOf(cause) {
+    return Object.freeze({ field: NO_FIELD, withheld: Object.freeze({ cause }) });
+}
+export function approvalFrameFamiliesDeclaration(reading) {
+    const j = judgeReading(reading);
+    return j.ok ? Object.freeze({ field: Object.freeze({ approvalFrameFamilies: j.families }) }) : withheldOf(j.cause);
+}
+export function frameFamiliesJudgementOf(reading) {
+    return judgeReading(reading);
+}
+function judgeReading(reading) {
+    const kind = guardedRead(() => (typeof reading === 'object' && reading !== null ? readOwnDataValue(reading, 'kind') : undefined));
+    if (kind === 'absent')
+        return { ok: false, cause: 'capability_absent' };
+    if (kind === 'declined')
+        return { ok: false, cause: 'capability_declined' };
+    if (kind !== 'confirmed')
+        return { ok: false, cause: 'capability_unreadable' };
+    const raw = guardedRead(() => readOwnDataValue(reading, 'families'));
+    const presented = presentedFamiliesOf(raw);
+    if (presented === 'declined' || presented === 'unreadable')
+        return { ok: false, cause: 'capability_unreadable' };
+    return { ok: true, families: intersectRenderedFamilies(presented, RENDERED_FRAME_FAMILY_WORDS) };
+}
+export function intersectRenderedFamilies(presented, rendered) {
+    const out = [];
+    for (const w of presented)
+        if (rendered.includes(w) && !out.includes(w))
+            appendOwnElement(out, w);
+    return Object.freeze(out);
+}

package/dist/approvalsStreamLiveCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectApprovalsStreamLiveCapability(caps) {
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'approvalsStreamLive',
     project: projectApprovalsStreamLiveCapability,
 });
-export function observedApprovalsStreamLive(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedApprovalsStreamLive(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function livePendingNeedsReconcile(reading) {