@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/compactionStatus.d.ts

@@ -0,0 +1,34 @@
+export interface CompactionStatusReading {
+    readonly compacting: boolean;
+    readonly since?: number;
+}
+export type CompactionStatusChange = {
+    readonly kind: 'opened';
+    readonly pass: string;
+    readonly since?: number;
+} | {
+    readonly kind: 'closed';
+    readonly pass: string;
+    readonly result?: 'success' | 'failed';
+    readonly error?: string;
+};
+export interface CompactionStatusTracker {
+    take(input: {} | null | undefined): CompactionStatusChange | null;
+    streamEnded(): CompactionStatusChange | null;
+    reading(): CompactionStatusReading;
+}
+export interface PrintCompactionStatusFrame {
+    readonly type: 'system';
+    readonly subtype: 'status';
+    readonly status: 'compacting' | null;
+    readonly compact_result?: 'success' | 'failed';
+    readonly compact_error?: string;
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export interface PrintCompactionStatusCtx {
+    readonly sessionId: string;
+    readonly mintUuid: () => string;
+}
+export declare function createCompactionStatusTracker(): CompactionStatusTracker;
+export declare function compactionStatusFrameOf(change: CompactionStatusChange | null | undefined, ctx: PrintCompactionStatusCtx): PrintCompactionStatusFrame | null;

package/dist/compactionStatus.js

@@ -0,0 +1,196 @@
+import { readOwnDataValue } from './ownKey.js';
+import { snapshotIsSubFlow, snapshotSegmentIdentity } from './adapter/types.js';
+const _printStatusFramePins = [true, true];
+void _printStatusFramePins;
+const CLOSED_PASS_MEMORY = 1024;
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+const own = (o, key) => (typeof o === 'object' && o !== null ? readOwnDataValue(o, key) : undefined);
+function chromeLane(ev) {
+    const lane = own(own(ev, 'laneProof'), 'lane');
+    if (typeof lane !== 'string' || lane.length === 0)
+        return 'unreadable';
+    return lane === 'main' ? 'main' : 'other';
+}
+function armLane(m) {
+    const snap = snapshotSegmentIdentity(m);
+    if (snap === null)
+        return 'unreadable';
+    return snapshotIsSubFlow(snap) ? 'other' : 'main';
+}
+function openOf(pass, lane, startedAt, trigger) {
+    if (lane === 'unreadable')
+        return null;
+    if (nonEmpty(trigger) === undefined)
+        return null;
+    return { kind: 'open', pass, main: lane === 'main', ...(typeof startedAt === 'number' && Number.isFinite(startedAt) ? { startedAt } : {}) };
+}
+function parse(input) {
+    const plane = own(input, 'plane');
+    if (plane === 'chrome') {
+        const ev = own(input, 'event');
+        return typeof ev === 'object' && ev !== null ? parseChrome(ev) : null;
+    }
+    if (plane === 'transcript') {
+        const msg = own(input, 'message');
+        return typeof msg === 'object' && msg !== null ? parseMessage(msg) : null;
+    }
+    if (own(input, 'kind') !== undefined)
+        return parseChrome(input);
+    return parseMessage(input);
+}
+function parseChrome(ev) {
+    const kind = own(ev, 'kind');
+    const pass = nonEmpty(own(ev, 'pass'));
+    if (pass === undefined)
+        return null;
+    if (kind === 'compaction_started')
+        return openOf(pass, chromeLane(ev), own(ev, 'startedAt'), own(ev, 'trigger'));
+    if (kind === 'compaction_outcome') {
+        const outcome = nonEmpty(own(ev, 'outcome'));
+        const reason = nonEmpty(own(ev, 'reason'));
+        return { kind: 'close-outcome', pass, ...(outcome !== undefined ? { outcome } : {}), ...(reason !== undefined ? { reason } : {}) };
+    }
+    return null;
+}
+function parseMessage(m) {
+    const type = own(m, 'type');
+    if (type === 'system') {
+        if (own(m, 'subtype') !== 'compact_boundary')
+            return null;
+        const pass = nonEmpty(own(own(m, 'compact_metadata'), '_sema_pass'));
+        return pass === undefined ? null : { kind: 'close-landed', pass };
+    }
+    const pass = nonEmpty(own(m, 'pass'));
+    if (pass === undefined)
+        return null;
+    if (type === 'compaction_started')
+        return openOf(pass, armLane(m), own(m, 'startedAt'), own(m, 'trigger'));
+    if (type === 'compaction_outcome') {
+        const outcome = nonEmpty(own(m, 'outcome'));
+        const reason = nonEmpty(own(m, 'reason'));
+        return { kind: 'close-outcome', pass, ...(outcome !== undefined ? { outcome } : {}), ...(reason !== undefined ? { reason } : {}) };
+    }
+    return null;
+}
+export function createCompactionStatusTracker() {
+    const open = new Map();
+    const closed = new Set();
+    const remember = (pass) => {
+        closed.add(pass);
+        if (closed.size > CLOSED_PASS_MEMORY) {
+            const oldest = closed.values().next().value;
+            if (oldest !== undefined)
+                closed.delete(oldest);
+        }
+    };
+    const mainOpen = () => {
+        let n = 0;
+        for (const e of open.values())
+            if (e.main)
+                n++;
+        return n;
+    };
+    const since = () => {
+        let min;
+        for (const e of open.values())
+            if (e.main && e.startedAt !== undefined && (min === undefined || e.startedAt < min))
+                min = e.startedAt;
+        return min;
+    };
+    const reading = () => {
+        if (mainOpen() === 0)
+            return { compacting: false };
+        const s = since();
+        return { compacting: true, ...(s !== undefined ? { since: s } : {}) };
+    };
+    return {
+        take(input) {
+            try {
+                if (typeof input !== 'object' || input === null)
+                    return null;
+                const p = parse(input);
+                if (p === null)
+                    return null;
+                if (p.kind === 'open') {
+                    if (open.has(p.pass) || closed.has(p.pass))
+                        return null;
+                    const before = mainOpen();
+                    open.set(p.pass, { main: p.main === true, ...(p.startedAt !== undefined ? { startedAt: p.startedAt } : {}) });
+                    if (before === 0 && p.main === true) {
+                        const s = since();
+                        return { kind: 'opened', pass: p.pass, ...(s !== undefined ? { since: s } : {}) };
+                    }
+                    return null;
+                }
+                const entry = open.get(p.pass);
+                remember(p.pass);
+                if (entry === undefined)
+                    return null;
+                open.delete(p.pass);
+                if (!entry.main || mainOpen() > 0)
+                    return null;
+                if (p.kind === 'close-landed')
+                    return { kind: 'closed', pass: p.pass, result: 'success' };
+                if (p.outcome === 'failed')
+                    return { kind: 'closed', pass: p.pass, result: 'failed', ...(p.reason !== undefined ? { error: p.reason } : {}) };
+                return { kind: 'closed', pass: p.pass };
+            }
+            catch {
+                return null;
+            }
+        },
+        streamEnded() {
+            try {
+                let lastMain;
+                for (const [pass, e] of open) {
+                    if (e.main)
+                        lastMain = pass;
+                    remember(pass);
+                }
+                const wasCompacting = lastMain !== undefined;
+                open.clear();
+                return wasCompacting ? { kind: 'closed', pass: lastMain } : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        reading() {
+            try {
+                return reading();
+            }
+            catch {
+                return { compacting: false };
+            }
+        },
+    };
+}
+export function compactionStatusFrameOf(change, ctx) {
+    try {
+        if (typeof change !== 'object' || change === null)
+            return null;
+        const sessionId = nonEmpty(own(ctx, 'sessionId'));
+        const mintUuid = own(ctx, 'mintUuid');
+        if (sessionId === undefined || typeof mintUuid !== 'function')
+            return null;
+        const kind = own(change, 'kind');
+        if (kind === 'opened')
+            return { type: 'system', subtype: 'status', status: 'compacting', uuid: String(mintUuid()), session_id: sessionId };
+        if (kind !== 'closed')
+            return null;
+        const result = own(change, 'result');
+        const error = result === 'failed' ? nonEmpty(own(change, 'error')) : undefined;
+        return {
+            type: 'system',
+            subtype: 'status',
+            status: null,
+            ...(result === 'success' || result === 'failed' ? { compact_result: result } : {}),
+            ...(error !== undefined ? { compact_error: error } : {}),
+            uuid: String(mintUuid()),
+            session_id: sessionId,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/coreValuePorts.d.ts

@@ -16,7 +16,6 @@ export interface AllowDenyPolicyOptionsView {
     deny?: string[];
     onInvalidName?: 'throw' | 'skip';
     onInvalidNameIssue?: (issue: AllowDenyInvalidNameIssueView) => void;
-    scope?: 'grant' | 'narrowing';
 }
 export interface AllowDenyInvalidNameIssueView {
     entry: string;
@@ -118,6 +117,13 @@ export type McpToolAxesReadView = {
     readonly ok: false;
     readonly problem: string;
 };
+export type McpToolFacesReadView = {
+    readonly ok: true;
+    readonly faces?: Readonly<Record<string, object>>;
+} | {
+    readonly ok: false;
+    readonly problem: string;
+};
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
@@ -141,8 +147,10 @@ export interface CoreValuePorts {
     judgeRuleToolName(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView;
     readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView;
     readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
+    ANTHROPIC_DEFAULT_BASE_URL: string;
+    readToolFaces(declared: {} | null | undefined): McpToolFacesReadView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -170,3 +178,5 @@ export declare function routePairingStatus(brain: {
 }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;
 export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView | undefined;
 export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;
+export declare function anthropicDefaultBaseUrl(): string | undefined;
+export declare function readToolFaces(declared: {} | null | undefined): McpToolFacesReadView | undefined;

package/dist/coreValuePorts.js

@@ -17,6 +17,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'judgeRuleToolName',
     'readRuleEntry',
     'readMcpToolAxes',
+    'ANTHROPIC_DEFAULT_BASE_URL',
+    'readToolFaces',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -109,3 +111,10 @@ export function readMcpToolAxes(declared) {
     const fn = port('readMcpToolAxes');
     return fn === undefined ? undefined : fn(declared);
 }
+export function anthropicDefaultBaseUrl() {
+    return port('ANTHROPIC_DEFAULT_BASE_URL');
+}
+export function readToolFaces(declared) {
+    const fn = port('readToolFaces');
+    return fn === undefined ? undefined : fn(declared);
+}

package/dist/decideFailureNote.js

@@ -1,25 +1,27 @@
 import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
-import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
-import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf } from './hitl/decisionConflict.js';
+import { fieldLimitRefusalContent, fieldLimitRefusalFromError } from './wireRefusalCopy.js';
+import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf, decisionGrantChangedContent } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
-    const bucket = settingsPermissionBucketRefusalFromError(err);
+    const bucket = fieldLimitRefusalFromError(err);
     const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
-    const answerInvalid = decisionConflictOf(err) === 'answer_invalid';
+    const conflict = decisionConflictOf(err);
+    const answerInvalid = conflict === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
-        (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
+        (bucket === null ? '' : ` — ${fieldLimitRefusalContent(bucket)}`) +
         (scenario === null ? '' : ` — ${scenarioNotAllowedContent(scenario, undefined, 'resumed_work')}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
         (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`) +
         (gone === null ? '' : ` — ${askGoneContent(gone)}`) +
-        (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : ''));
+        (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : '') +
+        (conflict === 'grant_changed' ? ` — ${decisionGrantChangedContent()}` : ''));
 }

package/dist/decideReceipt.js

@@ -3,7 +3,7 @@ import { readOwnDataValue } from './ownKey.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
 import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
-import { readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
+import { isSlotCarrier, readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
 import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
 const STATUS_RESUMING = 'resuming';
@@ -166,7 +166,7 @@ function askGoneRawCause(e) {
     return undefined;
 }
 export function askGoneFromError(e) {
-    if (typeof e !== 'object' || e === null)
+    if (!isSlotCarrier(e))
         return null;
     if (effectiveWireErrorCode(e) !== ASK_GONE)
         return null;

package/dist/deviceExecutorManagementCapability.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';
 import { capForDisplay } from './fleetTaskDesc.js';
@@ -44,7 +44,7 @@ const reader = createEngineCapReader({
     name: 'deviceExecutor.management',
     project: projectDeviceExecutorManagementCapability,
 });
-export function observedDeviceExecutorManagement(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedDeviceExecutorManagement(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function deviceManagementVerbsAvailable(reading) {

package/dist/deviceFlowPolling.js

@@ -2,7 +2,7 @@ import { SETTINGS_DEVICE_CODE_TTL_SECONDS, SETTINGS_DEVICE_POLL_INTERVAL_SECONDS
 function positiveSecondsOf(reading, key) {
     try {
         const desc = Object.getOwnPropertyDescriptor(reading, key);
-        if (desc === undefined || !('value' in desc))
+        if (desc === undefined || !Object.hasOwn(desc, 'value'))
             return undefined;
         const v = desc.value;
         return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;

package/dist/disableSkillsWire.d.ts

@@ -1,5 +1,5 @@
 export declare function refuseBadDisableSkills(v: unknown, who: string): void;
-export declare function refuseDisableSkillsConflict(disableSkills: unknown, skills: unknown, agents: unknown, who: string): void;
+export declare function refuseDisableSkillsConflict(disableSkills: unknown, skills: unknown, agents: unknown, who: string, userInvokedSkills?: readonly string[] | null): void;
 type DisableSkillsWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
 export type DisableSkillsDeclaration = {
     readonly field: {

package/dist/disableSkillsWire.js

@@ -17,14 +17,15 @@ export function refuseBadDisableSkills(v, who) {
 }
 const nonEmptyArray = (v) => Array.isArray(v) && v.length > 0;
 const anyAgentCarriesSkills = (agents) => Array.isArray(agents) && agents.some((a) => typeof a === 'object' && a !== null && nonEmptyArray(a.skills));
-export function refuseDisableSkillsConflict(disableSkills, skills, agents, who) {
+export function refuseDisableSkillsConflict(disableSkills, skills, agents, who, userInvokedSkills) {
     if (disableSkills !== true)
         return;
     const inSkills = nonEmptyArray(skills);
     const inAgents = anyAgentCarriesSkills(agents);
-    if (!inSkills && !inAgents)
+    const inNamed = nonEmptyArray(userInvokedSkills);
+    if (!inSkills && !inAgents && !inNamed)
         return;
-    const which = inSkills && inAgents ? 'skills 与 agents[].skills' : inSkills ? 'skills' : 'agents[].skills';
+    const which = [inSkills ? 'skills' : '', inAgents ? 'agents[].skills' : '', inNamed ? 'userInvokedSkills' : ''].filter((x) => x !== '').join(' 与 ');
     throw new TypeError(`${who}: disableSkills: true(这一发一只技能都不装)与非空的 ${which} 同在 —— 二选一:要关技能就别交技能,要交技能就别带 disableSkills。` +
         '上游对这一组合同样拒收(在任何东西跑起来之前);本层在装配前拒,不让它走一次往返。错误文本只报键名,不回显技能名。');
 }

package/dist/displayUntrusted.d.ts

@@ -1,6 +1,7 @@
 export declare const REDACTION_MARKER_PREFIX = "\u00ABredacted";
 export declare function looksLikeKnownSecret(s: string): boolean;
 export declare function isDiagnosticValueWord(value: string): boolean;
+export declare function percentBoundaryReadingOf(text: string): string;
 export declare function washCredentials(text: string): string;
 export type DisplayMark = 'escape' | 'dot' | 'space';
 export interface DisplayFace {