@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/index.js

@@ -15,6 +15,7 @@ export { __resetSubagentContentStoreConfigForTests, __resetSubagentOwnerLedgerFo
 export * from './engineAgentPanelStore.js';
 export * from './engineAgentAbsence.js';
 export * from './fleetAgentPanelProjection.js';
+export { reducePanelFrame, createPanelReduceState, PANEL_DELTA_OPS } from './panelReduce.js';
 export { _resetLiveQuestionStore, hasLocalQuestionResponder, hasQuestionOverlay, hasQuestionOverlayFor, onQuestionFrame, onQuestionFrameFor, publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, respondToQuestion, setQuestionRespond, } from './liveQuestionStore.js';
 export * from './engineInlineTaskStats.js';
 export * from './printToolResultFrame.js';
@@ -26,7 +27,7 @@ export * from './executionLaneCapability.js';
 export * from './approvalsStreamLiveCapability.js';
 export * from './peerLaneCapability.js';
 export * from './permissionRulesWriteCapability.js';
-export { __resetPermissionsAllowGrantReadingsForTests, forgetPermissionsAllowGrantReading, noteEngineCapsForPermissionsAllowGrant, observedPermissionsAllowGrant, permissionsAllowGrantAvailable, permissionsAllowGrantDoctorDetail, projectPermissionsAllowGrantCapability, } from './permissionsAllowGrantCapability.js';
+export { __resetPermissionsAllowGrantReadingsForTests, noteEngineCapsForPermissionsAllowGrant, observedPermissionsAllowGrant, permissionsAllowGrantAvailable, permissionsAllowGrantDoctorDetail, projectPermissionsAllowGrantCapability, } from './permissionsAllowGrantCapability.js';
 export * from './sessionPolicyCapability.js';
 export * from './memoryComplianceCapability.js';
 export * from './memoryOriginCapability.js';
@@ -34,9 +35,11 @@ export * from './memoryEntriesWire.js';
 export * from './memoryVerbsWire.js';
 export * from './deviceExecutorManagementCapability.js';
 export * from './mcpReconnect.js';
+export * from './hitl/parkExpiryJudgements.js';
+export * from './usageAnalytics.js';
 export * from './leaderConflict.js';
 export * from './runTerminal.js';
-export { providerRejectionResend } from './providerRejection.js';
+export { CORE_SEMA_TASK_TERMINAL_STATUSES, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, CORE_TERMINAL_CAUSE_KINDS, SDK_FLEET_TASK_TERMINAL_STATUSES, SDK_RUN_TERMINAL_STATUSES, ccTaskTerminalStatusOf, isCoreSemaTaskTerminal, isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTerminalCauseKind, isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess, isSdkRunTerminal, isSdkRunTerminalNotSuccess, } from './terminalStatuses.js';
 export * from './runCancelContext.js';
 export * from './argvFlagValue.js';
 export * from './readFacePosture.js';
@@ -94,6 +97,7 @@ export * from './retainBackgroundWireCaps.js';
 export * from './oneShotWireCaps.js';
 export * from './rewindWireCaps.js';
 export * from './rewindArchiveCapability.js';
+export * from './rewindEngineAction.js';
 export * from './fileHistoryCaptureCapability.js';
 export { FILE_HISTORY_LEG_VERDICTS, fileHistoryLegNoticeVerdict, fileHistoryLegNoticeSentence, fileHistoryDeclarationOfBody, createFileHistoryDeclarationLedger, } from './fileHistoryLegNotice.js';
 export * from './callerCwdCapability.js';
@@ -111,6 +115,7 @@ export * from './liveModelCatalog.js';
 export * from './modelBudgetRule.js';
 export * from './modelIdentityResolvability.js';
 export * from './sessionModelLatch.js';
+export * from './modelSwitchFallback.js';
 export * from './effortWire.js';
 export * from './adapter/types.js';
 export * from './adapter/downstream/turnUsageToModelUsage.js';
@@ -122,7 +127,7 @@ export * from './adapter/activeRunSelfHeal.js';
 export * from './request/taskRequest.js';
 export { disableSkillsDeclaration, disableSkillsDeclarationSettled } from './disableSkillsWire.js';
 export { approvalReachDeclaration, approvalReachDeclarationSettled } from './approvalReachWire.js';
-export { PERMISSIONS_KEPT_REASONS, WIRE_RULE_TRUST_ORDER, permissionsDeclaration, permissionsDeclarationReport } from './permissionsDeclaration.js';
+export { PERMISSIONS_KEPT_REASONS, WIRE_RULE_TRUST_ORDER, permissionsAllowKeptNotice, permissionsDeclaration, permissionsDeclarationReport } from './permissionsDeclaration.js';
 export * from './clientSlice.js';
 export * from './host.js';
 export { abortableSleep } from './abortableSleep.js';
@@ -137,7 +142,7 @@ export * from './limitsWire.js';
 export * from './interactiveToolsWire.js';
 export * from './headlessPermissionModeWire.js';
 export * from './headlessReconnectWire.js';
-export { coerceTaskStatus, coerceWorkflowStatus, CONTROL_TOOL_VERBS, FLEET_TASK_ROW_KEYS_NOT_PROJECTED, FLEET_TASK_ROW_WIRE_KEYS, FLEET_TASK_VIEW_KEYS, FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED, FLEET_WORKFLOW_ROW_WIRE_KEYS, FLEET_WORKFLOW_VIEW_KEYS, projectDescription, projectTasks, projectWorkflows, TERMINAL_FLEET_TASK_STATUSES, wireResumable, wireRowUsage, } from './fleet/fleetProjection.js';
+export { coerceTaskStatus, coerceWorkflowStatus, CONTROL_TOOL_VERBS, FLEET_TASK_ROW_KEYS_NOT_PROJECTED, FLEET_TASK_ROW_WIRE_KEYS, FLEET_TASK_VIEW_KEYS, FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED, FLEET_WORKFLOW_ROW_WIRE_KEYS, FLEET_WORKFLOW_VIEW_KEYS, projectDescription, projectTasks, projectWorkflows, wireResumable, wireRowUsage, } from './fleet/fleetProjection.js';
 export * from './fleet/fleetLedger.js';
 export * from './fleet/workflowSizeWarning.js';
 export * from './subagent/engineDelegatedPrompt.js';
@@ -158,12 +163,11 @@ export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
 export { classifyToolHistoryMismatch, readToolHistoryMismatchKey, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
 export { toolHistoryBadTurnSentence } from './toolHistoryBadTurn.js';
-export { classifyRegistryConflict, isScopeGoneError } from './registryConflict.js';
 export { deviceFlowPollingPlan } from './deviceFlowPolling.js';
 export { createPromptDeliveryLedger, promptKnownUndelivered, withoutUndeliveredPrompts } from './promptDelivery.js';
 export { mintUserAttachmentEnvelope } from './userAttachmentEnvelope.js';
 export { encodeHumanTurn, deliveredUuidsOf } from './humanTurn.js';
-export { noteEngineCapsForAttachmentSeat, observedAttachmentSeat, forgetAttachmentSeatReading, __resetAttachmentSeatReadingsForTests, } from './attachmentSeatCapability.js';
+export { noteEngineCapsForAttachmentSeat, observedAttachmentSeat, __resetAttachmentSeatReadingsForTests, } from './attachmentSeatCapability.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
@@ -206,15 +210,21 @@ export * from './hitl/sessionPolicyWire.js';
 export * from './hitl/sessionPolicyDeliverable.js';
 export * from './hitl/approvalsFeed.js';
 export * from './hitl/livePendingAsk.js';
-export { replayedApprovalDisposition } from './hitl/replayedApproval.js';
+export { replayedApprovalDisposition, replayedApprovalSentence } from './hitl/replayedApproval.js';
+export { hasLedgerPositionKey } from './hitl/gateLedger.js';
 export { MODE_ARBITRATION, automaticAnswerVerdict, mandatedApprovalDetailOf, permissionRequestHookScope, } from './hitl/automaticAnswerVerdict.js';
 export { classifyDecisionRefusal, liveAskPendingReading, decisionRefusalClosesOut, undeliverableDecisionContent, } from './hitl/decisionRefusal.js';
 export { noAllowCauseOf } from './hitl/noAllowCause.js';
 export { policyDenyReason } from './hitl/frameRouter.js';
-export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, } from './hitl/allowRuleShadow.js';
+export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, allowRuleShadowSentence, } from './hitl/allowRuleShadow.js';
 export { projectCrashConverged } from './hitl/crashConverged.js';
 export * from './hitl/crashConvergedNotice.js';
+export { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
+export { approvalCompleteCauseOf } from './hitl/approvalEndingCause.js';
 export * from './interactiveHalt.js';
+export { fireInteractiveInterrupt } from './interactiveInterrupt.js';
+export { listDevices, readSessionBinding, rebindSession, reconcileRebindOutcome, rebindProvesRequestNotApplied } from './deviceRebind.js';
+export { resolveEngineEnvSourcing, engineEnvView } from './engineEnvSourcing.js';
 export * from './compensations.js';
 export * from './request/printNotification.js';
 export * from './seatContract.js';
@@ -235,3 +245,5 @@ export * from './env/localeGeo.js';
 export * from './env/localeTag.js';
 export * from './env/uiLanguage.js';
 export * from './ruleRemovalConsequence.js';
+export { engineCredentialRequirementOf } from './engineCredentialRequirement.js';
+export { isSessionIdPathSegment } from './sessionIdSegment.js';

package/dist/interactiveInterrupt.d.ts

@@ -0,0 +1,8 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { InteractiveHaltInterruptOutcome } from './interactiveHalt.js';
+export type InteractiveInterruptRuns = Pick<AgentClient['runs'], 'interrupt'>;
+export interface InteractiveInterruptOptions {
+    readonly sessionId?: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+export declare function fireInteractiveInterrupt(runs: InteractiveInterruptRuns | null | undefined, taskId: string, opts?: InteractiveInterruptOptions): Promise<InteractiveHaltInterruptOutcome>;

package/dist/interactiveInterrupt.js

@@ -0,0 +1,54 @@
+import { atMostOnceVerdictOf } from './atMostOnce.js';
+import { readOwnDataValue } from './ownKey.js';
+function guardedSlot(e, key) {
+    if (e === null || (typeof e !== 'object' && typeof e !== 'function'))
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+function outcomeOfFailure(e) {
+    const v = atMostOnceVerdictOf(e);
+    if (v.status === undefined && v.name === 'SyntaxError')
+        return { kind: 'halted' };
+    if (v.delivery === 'rejected' && v.status !== undefined) {
+        return { kind: 'refused', status: v.status, ...(v.code !== undefined ? { errorCode: v.code } : {}) };
+    }
+    return { kind: 'transport', ...(v.name !== undefined ? { detail: v.name } : {}) };
+}
+function turnCutOf(receipt) {
+    if (receipt === null || typeof receipt !== 'object')
+        return undefined;
+    try {
+        if (Array.isArray(receipt))
+            return undefined;
+        const v = readOwnDataValue(receipt, 'turnCut');
+        return typeof v === 'boolean' ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function fireInteractiveInterrupt(runs, taskId, opts = {}) {
+    const verb = guardedSlot(runs, 'interrupt');
+    if (typeof verb !== 'function')
+        return { kind: 'unarmed' };
+    const sessionId = guardedSlot(opts, 'sessionId');
+    const signal = guardedSlot(opts, 'signal');
+    const callOpts = {
+        ...(typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {}),
+        ...(signal !== undefined && signal !== null ? { signal } : {}),
+    };
+    let receipt;
+    try {
+        receipt = await verb.call(runs, taskId, undefined, callOpts);
+    }
+    catch (e) {
+        return outcomeOfFailure(e);
+    }
+    const turnCut = turnCutOf(receipt);
+    return { kind: 'halted', ...(turnCut !== undefined ? { turnCut } : {}) };
+}

package/dist/limitsWire.d.ts

@@ -21,6 +21,11 @@ export type LimitsParseResult = {
     error: string;
 };
 export declare function parseLimitsArgv(argv: string[]): LimitsParseResult;
+export declare function explicitLimitFlagNames(parsed: LimitsParseResult): string[];
+export declare function limitsSupportNotice(reading: {
+    observed: boolean;
+    version?: unknown;
+}, flags: readonly string[]): string | undefined;
 export type HeadlessEnvLimitsResult = {
     ok: true;
     limits: HeadlessLimits | undefined;

package/dist/limitsWire.js

@@ -1,5 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { lastFlagValue } from './argvFlagValue.js';
+import { engineVersionTier, SUPPORT_FLOOR } from './supportFloor.js';
+import { readThrownSlot } from './wireFailureShape.js';
 export const HEADLESS_DEADLINE_ENV = 'SEMA_HEADLESS_DEADLINE_SEC';
 export const HEADLESS_MAX_TURNS_ENV = 'SEMA_HEADLESS_MAX_TURNS';
 export const HEADLESS_MAX_TOKENS_ENV = 'SEMA_HEADLESS_MAX_TOKENS';
@@ -10,6 +12,11 @@ export const MAX_TURNS_MAX = Number.MAX_SAFE_INTEGER;
 export const MAX_TOKENS_MIN = 1;
 export const MAX_TOKENS_MAX = Number.MAX_SAFE_INTEGER;
 const SEC_TO_MS = 1_000;
+const LIMIT_FLAG_OF_KEY = {
+    maxWalltimeMs: '--deadline',
+    maxTurns: '--max-turns',
+    maxOutputTokens: '--max-tokens',
+};
 const DEADLINE_USAGE = `sema: --deadline expects a whole number of seconds between ${DEADLINE_SEC_MIN} and ${DEADLINE_SEC_MAX}.\n` +
     '  --deadline <sec>     wall-clock budget for this run (sema superset — no upstream equivalent):\n' +
     '                       reaching it ends the run LOUDLY (failed / limits.max_walltime_exceeded)\n' +
@@ -39,21 +46,21 @@ function hasAnyLimit(l) {
 }
 export function parseLimitsArgv(argv) {
     const limits = {};
-    const dl = lastFlagValue(argv, '--deadline');
+    const dl = lastFlagValue(argv, LIMIT_FLAG_OF_KEY.maxWalltimeMs);
     if (dl.present) {
         const n = dl.raw !== undefined ? parseIntInDomain(dl.raw, DEADLINE_SEC_MIN, DEADLINE_SEC_MAX) : null;
         if (n === null)
             return { ok: false, error: DEADLINE_USAGE };
         limits.maxWalltimeMs = n * SEC_TO_MS;
     }
-    const mt = lastFlagValue(argv, '--max-turns');
+    const mt = lastFlagValue(argv, LIMIT_FLAG_OF_KEY.maxTurns);
     if (mt.present) {
         const n = mt.raw !== undefined ? parseIntInDomain(mt.raw, MAX_TURNS_MIN, MAX_TURNS_MAX) : null;
         if (n === null)
             return { ok: false, error: MAX_TURNS_USAGE };
         limits.maxTurns = n;
     }
-    const mk = lastFlagValue(argv, '--max-tokens');
+    const mk = lastFlagValue(argv, LIMIT_FLAG_OF_KEY.maxOutputTokens);
     if (mk.present) {
         const n = mk.raw !== undefined ? parseIntInDomain(mk.raw, MAX_TOKENS_MIN, MAX_TOKENS_MAX) : null;
         if (n === null)
@@ -62,6 +69,45 @@ export function parseLimitsArgv(argv) {
     }
     return { ok: true, ...(hasAnyLimit(limits) ? { limits } : {}) };
 }
+export function explicitLimitFlagNames(parsed) {
+    if (typeof parsed !== 'object' || parsed === null || parsed.ok !== true)
+        return [];
+    const limits = parsed.limits;
+    if (typeof limits !== 'object' || limits === null)
+        return [];
+    return Object.keys(LIMIT_FLAG_OF_KEY).filter((k) => limits[k] !== undefined).map((k) => LIMIT_FLAG_OF_KEY[k]);
+}
+const LIMIT_FLAGS_READ_MAX = 64;
+function limitFlagWordsIn(flags) {
+    const all = Object.values(LIMIT_FLAG_OF_KEY);
+    if (typeof flags !== 'object' || flags === null)
+        return all;
+    const length = readThrownSlot(flags, 'length');
+    if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0)
+        return all;
+    const given = new Set();
+    for (let i = 0; i < Math.min(length, LIMIT_FLAGS_READ_MAX); i++)
+        given.add(readThrownSlot(flags, String(i)));
+    const shown = all.filter((w) => given.has(w));
+    return shown.length > 0 ? shown : all;
+}
+export function limitsSupportNotice(reading, flags) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    if (readThrownSlot(reading, 'observed') !== true)
+        return undefined;
+    const rawVersion = readThrownSlot(reading, 'version');
+    const version = typeof rawVersion === 'string' ? rawVersion : undefined;
+    const tier = engineVersionTier(version);
+    if (tier === 'engine')
+        return undefined;
+    const shown = limitFlagWordsIn(flags);
+    const text = shown.join(' / ');
+    if (tier === 'legacy') {
+        return `[sema] The engine reports version ${String(version)}, older than ${SUPPORT_FLOOR.server} (the oldest engine this client supports); it may ignore ${text}.`;
+    }
+    return `[sema] The engine did not report a version this client can read, so it cannot be confirmed that it honors ${text}; ${shown.length > 1 ? 'they were' : 'it was'} sent anyway.`;
+}
 export function headlessLimitsFromEnv(env = hostEnv()) {
     const out = {};
     const dl = env[HEADLESS_DEADLINE_ENV]?.trim();

package/dist/liveModelCatalog.d.ts

@@ -1,3 +1,4 @@
+import type { AgentClient } from '@sema-agent/sdk';
 export interface LiveModelInfo {
     name: string;
     id?: string;
@@ -6,11 +7,20 @@ export interface LiveModelInfo {
     vision?: boolean;
     routePairing?: string;
     supportedEffortLevels?: string[];
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    atMentionable?: boolean;
+    compat?: LiveModelCompat;
     [k: string]: unknown;
 }
 export interface LiveModelCatalog {
     models: LiveModelInfo[];
     default: string;
+    defaultModel?: {
+        readonly id: string;
+        readonly name?: string;
+    };
+    droppedEntries?: readonly LiveModelDroppedEntry[];
 }
 export declare function setLiveModelCatalog(next: LiveModelCatalog | null): void;
 export declare function setLiveModelCatalogRefresher(fn: (() => Promise<LiveModelCatalog | null>) | null): void;
@@ -33,8 +43,93 @@ export type EffortLevelsReading = {
 export declare function effortLevelsOf(model: string | undefined, catalog?: LiveModelCatalog | null): EffortLevelsReading;
 export declare function effortLevelHonored(reading: EffortLevelsReading, level: string): 'yes' | 'no' | 'unknown';
 export declare function liveDefaultModelName(): string | null;
+type SdkModelsListResult = Awaited<ReturnType<AgentClient['models']['list']>>;
+type SdkDroppedEntry = SdkModelsListResult extends {
+    droppedEntries?: ReadonlyArray<infer E>;
+} ? E : never;
+type SdkModelInfo = SdkModelsListResult extends {
+    models: ReadonlyArray<infer M>;
+} ? M : never;
+export type LiveModelCompat = NonNullable<SdkModelInfo extends {
+    compat?: infer C;
+} ? C : never>;
+export type LiveModelDroppedEntry = SdkDroppedEntry extends {
+    reasonCode: infer R;
+} ? Omit<SdkDroppedEntry, 'reasonCode'> & {
+    readonly reasonCode: R | (string & {});
+} : SdkDroppedEntry;
+export type ModelDroppedEntriesReading = {
+    readonly kind: 'reported';
+    readonly entries: readonly LiveModelDroppedEntry[];
+    readonly unreadable: number;
+} | {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'malformed' | 'unreadable';
+};
+export declare function droppedModelEntriesOf(catalog?: LiveModelCatalog | null): ModelDroppedEntriesReading;
 export interface RoutePairingVerdict {
     verdict: 'ok' | 'broken' | 'unknown';
     posture?: string;
 }
 export declare function routePairingVerdict(v: unknown): RoutePairingVerdict;
+export type LiveModelCatalogReading = {
+    readonly kind: 'read';
+    readonly catalog: LiveModelCatalog;
+    readonly unreadableRows: number;
+    readonly defaultModelMalformed?: true;
+} | {
+    readonly kind: 'unreadable';
+    readonly why: 'not_an_object' | 'models_not_array' | 'default_missing' | 'unreadable';
+};
+export declare function readLiveModelCatalog(body: unknown): LiveModelCatalogReading;
+export type LiveDefaultModelReading = {
+    readonly kind: 'listed';
+    readonly name: string;
+    readonly from: 'defaultModel.name' | 'defaultModel.id';
+} | {
+    readonly kind: 'not_listed';
+    readonly id: string;
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'not_reported' | 'unreadable';
+};
+export declare function liveDefaultModelOf(catalog?: LiveModelCatalog | null): LiveDefaultModelReading;
+export type AtMentionReading = {
+    readonly kind: 'allowed';
+} | {
+    readonly kind: 'refused';
+} | {
+    readonly kind: 'not_governed';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'model_not_listed' | 'malformed' | 'unreadable';
+};
+export declare function atMentionOf(model: string | undefined, catalog?: LiveModelCatalog | null): AtMentionReading;
+export type ModelCompatReading = {
+    readonly kind: 'declared';
+    readonly compat: Readonly<LiveModelCompat>;
+} | {
+    readonly kind: 'not_declared';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'model_not_listed' | 'malformed' | 'unreadable';
+};
+export declare function modelCompatOf(model: string | undefined, catalog?: LiveModelCatalog | null): ModelCompatReading;
+export interface LiveModelRowView {
+    readonly name: string;
+    readonly id?: string;
+    readonly provider?: string;
+    readonly reasoning?: boolean;
+    readonly contextWindow?: number;
+    readonly maxOutputTokens?: number;
+    readonly isDefault: boolean;
+    readonly vision: ImageVision;
+    readonly effort: EffortLevelsReading;
+    readonly routePairing: RoutePairingVerdict;
+    readonly atMention: AtMentionReading;
+    readonly compat: ModelCompatReading;
+}
+export declare function liveModelRowsOf(catalog?: LiveModelCatalog | null): readonly LiveModelRowView[] | null;
+export {};