@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/inheritEnvCapability.js

@@ -1,6 +1,6 @@
 import { engineCapValue } from './engineCapsCache.js';
 import { isUiLanguage } from './env/uiLanguage.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const OWN_CREDENTIALS_WITHHELD_KEY = 'inherit_env.own_credentials_withheld';
 const OWN_CREDENTIAL_VALUES_WITHHELD_KEY = 'inherit_env.own_credential_values_withheld';
@@ -46,39 +46,45 @@ function inheritEnvWordReading(baseUrl, key) {
         return UNOBSERVED;
     }
 }
-export function observedInheritEnvOwnCredentialsWithheld(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedInheritEnvOwnCredentialsWithheld(baseUrl = engineWireTargetBaseUrl()) {
     return inheritEnvWordReading(baseUrl, OWN_CREDENTIALS_WITHHELD_KEY);
 }
-export function observedInheritEnvOwnCredentialValuesWithheld(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedInheritEnvOwnCredentialValuesWithheld(baseUrl = engineWireTargetBaseUrl()) {
     return inheritEnvWordReading(baseUrl, OWN_CREDENTIAL_VALUES_WITHHELD_KEY);
 }
 const ALL = Object.freeze({ send: 'all' });
 const omit = (reason) => Object.freeze({ send: 'omit', reason });
 function fieldOf(input, key) {
     try {
+        if (!Object.hasOwn(input, key))
+            return undefined;
         return input[key];
     }
     catch {
         return undefined;
     }
 }
-function capabilityReasonOf(reading) {
+function readingClassOf(reading) {
     try {
-        if (typeof reading !== 'object' || reading === null)
-            return 'capability_unreadable';
+        if (typeof reading !== 'object' || reading === null || !Object.hasOwn(reading, 'kind'))
+            return 'unreadable';
         const kind = reading.kind;
-        if (kind === 'confirmed')
-            return undefined;
-        if (kind === 'absent')
-            return 'capability_absent';
-        if (kind === 'declined')
-            return 'capability_declined';
-        return 'capability_unreadable';
+        if (kind === 'confirmed' || kind === 'absent' || kind === 'declined')
+            return kind;
+        return 'unreadable';
     }
     catch {
-        return 'capability_unreadable';
+        return 'unreadable';
     }
 }
+function capabilityReasonOf(reading) {
+    const cls = readingClassOf(reading);
+    return cls === 'confirmed' ? undefined : cls === 'absent' ? 'capability_absent' : cls === 'declined' ? 'capability_declined' : 'capability_unreadable';
+}
+function valuesReasonOf(reading) {
+    const cls = readingClassOf(reading);
+    return cls === 'confirmed' ? undefined : cls === 'absent' ? 'capability_values_absent' : cls === 'declined' ? 'capability_values_declined' : 'capability_values_unreadable';
+}
 export function inheritEnvIntentOf(input) {
     if (typeof input !== 'object' || input === null || Array.isArray(input))
         return omit('lane');
@@ -91,19 +97,27 @@ export function inheritEnvIntentOf(input) {
         return omit(cap);
     if (fieldOf(input, 'serviceIdentityVerified') !== true)
         return omit('identity_unverified');
+    const values = valuesReasonOf(fieldOf(input, 'ownCredentialValuesWithheld'));
+    if (values !== undefined)
+        return omit(values);
     return ALL;
 }
 export function inheritEnvNotConfirmedNotice(lang) {
     return renderMessage(msg('session.inheritEnv.notConfirmed'), isUiLanguage(lang) ? lang : undefined);
 }
+export function inheritEnvValuesNotConfirmedNotice(lang) {
+    return renderMessage(msg('session.inheritEnv.valuesNotConfirmed'), isUiLanguage(lang) ? lang : undefined);
+}
 export function inheritEnvNoticeOf(intent, lang) {
     try {
         if (typeof intent !== 'object' || intent === null || intent.send !== 'omit')
             return undefined;
         const reason = intent.reason;
-        return reason === 'capability_absent' || reason === 'capability_declined' || reason === 'capability_unreadable'
-            ? inheritEnvNotConfirmedNotice(lang)
-            : undefined;
+        if (reason === 'capability_absent' || reason === 'capability_declined' || reason === 'capability_unreadable')
+            return inheritEnvNotConfirmedNotice(lang);
+        if (reason === 'capability_values_absent' || reason === 'capability_values_declined' || reason === 'capability_values_unreadable')
+            return inheritEnvValuesNotConfirmedNotice(lang);
+        return undefined;
     }
     catch {
         return undefined;

package/dist/inheritEnvWire.d.ts

@@ -15,6 +15,7 @@ export declare function inheritEnvDeclaration(word: unknown, serverVersion: stri
 export declare function inheritEnvWithheldNotice(withheld: InheritEnvWithheld, lang?: UiLanguage): string;
 export interface InheritEnvRefusalDetail {
     readonly code: string;
+    readonly field?: 'inheritEnv';
 }
 export declare function inheritEnvRefusalFromError(err: unknown, sentRequest: TaskRequestLike | undefined): InheritEnvRefusalDetail | null;
-export declare function inheritEnvRefusalContent(_detail: InheritEnvRefusalDetail, lang?: UiLanguage): string;
+export declare function inheritEnvRefusalContent(detail: InheritEnvRefusalDetail, lang?: UiLanguage): string;

package/dist/inheritEnvWire.js

@@ -1,6 +1,6 @@
 import { msg, renderMessage } from './i18n/translate.js';
 import { INHERIT_ENV_WORDS, isInheritEnvWord } from './request/taskRequest.js';
-import { fieldLimitRefusalFromError } from './wireRefusalCopy.js';
+import { readRefusalNamedFields } from './wireFailureShape.js';
 import { engineVersionTier } from './supportFloor.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
 const EMPTY_DECLARATION = Object.freeze({ field: Object.freeze({}) });
@@ -39,6 +39,7 @@ function inheritEnvWithheldKey(withheld) {
     }
 }
 const FIELD_INVALID = 'request.field_invalid';
+const INHERIT_ENV_FIELD = 'inheritEnv';
 function readGuarded(o, key) {
     if (typeof o !== 'object' || o === null)
         return undefined;
@@ -50,14 +51,19 @@ export function inheritEnvRefusalFromError(err, sentRequest) {
             return null;
         if (readGuarded(err, 'errorCode') !== FIELD_INVALID)
             return null;
-        if (fieldLimitRefusalFromError(err) !== null)
+        if (typeof err !== 'object' || err === null)
             return null;
-        return Object.freeze({ code: FIELD_INVALID });
+        const named = readRefusalNamedFields(err);
+        if (named.length === 0)
+            return Object.freeze({ code: FIELD_INVALID });
+        if (named.includes(INHERIT_ENV_FIELD))
+            return Object.freeze({ code: FIELD_INVALID, field: INHERIT_ENV_FIELD });
+        return null;
     }
     catch {
         return null;
     }
 }
-export function inheritEnvRefusalContent(_detail, lang) {
-    return renderMessage(msg('session.inheritEnv.refusal'), lang);
+export function inheritEnvRefusalContent(detail, lang) {
+    return renderMessage(msg(readGuarded(detail, 'field') === INHERIT_ENV_FIELD ? 'session.inheritEnv.refusalNamed' : 'session.inheritEnv.refusal'), lang);
 }

package/dist/interactiveHalt.d.ts

@@ -11,13 +11,15 @@ export type InteractiveHaltInterruptOutcome = {
 } | {
     kind: 'transport';
     detail?: string | undefined;
+} | {
+    kind: 'withheld';
 };
 export interface InteractiveHaltInput {
     readonly parked?: boolean | undefined;
     readonly detachArmed?: boolean | undefined;
     readonly interruptOutcome?: InteractiveHaltInterruptOutcome | undefined;
 }
-export type InteractiveHaltReason = 'first-shot' | 'halted' | 'engine-says-run-level' | 'no-verdict-on-parked-card' | 'no-verdict-detach-armed' | 'no-verdict-not-parked' | 'refused-no-escalation' | 'unknown-outcome';
+export type InteractiveHaltReason = 'first-shot' | 'halted' | 'engine-says-run-level' | 'no-verdict-on-parked-card' | 'no-verdict-detach-armed' | 'no-verdict-not-parked' | 'refused-no-escalation' | 'unknown-outcome' | 'handed-off';
 export interface InteractiveHaltPlan {
     readonly action: 'interrupt' | 'escalate-cancel' | 'none';
     readonly reason: InteractiveHaltReason;

package/dist/interactiveHalt.js

@@ -32,6 +32,8 @@ export function planInteractiveHalt(input) {
             ? { action: 'escalate-cancel', reason: 'engine-says-run-level' }
             : { action: 'none', reason: 'refused-no-escalation' };
     }
+    if (kind === 'withheld')
+        return { action: 'none', reason: 'handed-off' };
     if (kind === 'transport' || kind === 'unarmed') {
         if (input.parked === true)
             return { action: 'escalate-cancel', reason: 'no-verdict-on-parked-card' };

package/dist/interactiveInterrupt.d.ts

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

package/dist/interactiveInterrupt.js

@@ -1,5 +1,6 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readOwnDataValue } from './ownKey.js';
+import { noteInteractiveStopRequested, ownSlotOf } from './sessionBackground.js';
 function guardedSlot(e, key) {
     if (e === null || (typeof e !== 'object' && typeof e !== 'function'))
         return undefined;
@@ -33,6 +34,20 @@ function turnCutOf(receipt) {
     }
 }
 export async function fireInteractiveInterrupt(runs, taskId, opts = {}) {
+    if (opts !== null && typeof opts === 'object') {
+        const ws = ownSlotOf(opts, 'wire');
+        if (ws.state === 'unreadable')
+            return { kind: 'withheld' };
+        if (ws.state === 'data') {
+            const wire = ws.value;
+            if (wire !== null) {
+                if (typeof wire !== 'object')
+                    return { kind: 'withheld' };
+                if (noteInteractiveStopRequested(wire, taskId) === 'withheld')
+                    return { kind: 'withheld' };
+            }
+        }
+    }
     const verb = guardedSlot(runs, 'interrupt');
     if (typeof verb !== 'function')
         return { kind: 'unarmed' };

package/dist/interactiveToolsWire.d.ts

@@ -7,6 +7,8 @@ export type InteractiveToolsResolution = {
     source: 'default' | 'env' | 'plan-flag';
     warning?: string;
 };
-export declare function planModeExplicitlyRequested(argv: readonly string[]): boolean;
-export declare function resolveHeadlessInteractiveTools(argv: readonly string[], env?: EnvLike): InteractiveToolsResolution;
+export interface HeadlessInteractiveToolsStance {
+    readonly permissionMode?: string;
+}
+export declare function resolveHeadlessInteractiveTools(stance: HeadlessInteractiveToolsStance | undefined, env?: EnvLike): InteractiveToolsResolution;
 export declare function _resetInteractiveToolsWireForTest(): void;

package/dist/interactiveToolsWire.js

@@ -1,13 +1,13 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff, envFlagOn } from './envFlag.js';
-import { permissionModeFromArgv } from './headlessPermissionModeWire.js';
+import { flagString } from './flagInput.js';
 export const HEADLESS_INTERACTIVE_TOOLS_ENV = 'SEMA_HEADLESS_INTERACTIVE_TOOLS';
-export function planModeExplicitlyRequested(argv) {
-    return permissionModeFromArgv(argv) === 'plan';
+function stanceIsPlanMode(stance) {
+    return flagString(stance, 'permissionMode') === 'plan';
 }
 let warnedInvalidEnv = false;
-export function resolveHeadlessInteractiveTools(argv, env = hostEnv()) {
-    if (planModeExplicitlyRequested(argv)) {
+export function resolveHeadlessInteractiveTools(stance, env = hostEnv()) {
+    if (stanceIsPlanMode(stance)) {
         return { fields: {}, source: 'plan-flag' };
     }
     const raw = env[HEADLESS_INTERACTIVE_TOOLS_ENV]?.trim();

package/dist/jsonFaithful.d.ts

@@ -0,0 +1,20 @@
+export declare const shapeTag: (v: {} | null | undefined) => string;
+export declare const isPlainRecord: (v: {} | null | undefined) => v is Record<string, {} | null | undefined>;
+export type MaterializeResult = {
+    readonly bad: string;
+} | {
+    readonly value: {} | null | undefined;
+};
+export interface MaterializeGuard {
+    readonly budget: {
+        left: number;
+    };
+    readonly visited?: WeakSet<object>;
+}
+export interface MaterializeOptions {
+    readonly guard?: MaterializeGuard;
+    readonly functionLeaf?: (captured: Readonly<Record<string, {} | null | undefined>>, key: string) => boolean;
+    readonly undefinedIsBad?: boolean;
+}
+export declare const materializeJsonFaithful: (v: {} | null | undefined, path: string, seen?: Set<object>, opts?: MaterializeOptions) => MaterializeResult;
+export declare const jsonFaithfulCost: (v: {} | null | undefined) => number;

package/dist/jsonFaithful.js

@@ -0,0 +1,152 @@
+import { appendOwnElement } from './ownKey.js';
+export const shapeTag = (v) => {
+    try {
+        const proto = Object.getPrototypeOf(v);
+        const carrier = proto === null
+            ? 'null-prototype'
+            : String(proto?.constructor?.name ?? 'anonymous');
+        return `typeof=${typeof v} / ${Object.prototype.toString.call(v)} / prototype=${carrier}`;
+    }
+    catch {
+        return `typeof=${typeof v} / shape=unreadable`;
+    }
+};
+export const isPlainRecord = (v) => {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    if (proto === null)
+        return true;
+    if (typeof proto !== 'object')
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(proto, 'constructor'))
+        return false;
+    const ctor = proto.constructor;
+    if (typeof ctor !== 'function')
+        return false;
+    if (Function.prototype.toString.call(ctor) !== Function.prototype.toString.call(Object))
+        return false;
+    return ctor.prototype === proto;
+};
+export const materializeJsonFaithful = (v, path, seen = new Set(), opts = {}) => {
+    const guard = opts.guard;
+    if (guard !== undefined && --guard.budget.left < 0)
+        return { bad: `${path}(超出捕获预算 ⇒ 读数过大)` };
+    if (v === null)
+        return { value: null };
+    const t = typeof v;
+    if (t === 'string' || t === 'boolean')
+        return { value: v };
+    if (t === 'number') {
+        return Number.isFinite(v) ? { value: v } : { bad: `${path}(非有限数 ⇒ 序列化成 null)` };
+    }
+    if (t !== 'object')
+        return { bad: `${path}(typeof=${t} 不是 JSON 值)` };
+    const o = v;
+    if (seen.has(o))
+        return { bad: `${path}(循环引用)` };
+    if (guard?.visited !== undefined) {
+        if (guard.visited.has(o))
+            return { bad: `${path}(同一对象第二次出现 ⇒ 共享引用不是设置文件形)` };
+        guard.visited.add(o);
+    }
+    if (guard !== undefined && --guard.budget.left < 0)
+        return { bad: `${path}(超出捕获预算 ⇒ 读数过大)` };
+    const toJSONProp = o.toJSON;
+    if (typeof toJSONProp === 'function')
+        return { bad: `${path}(自报 toJSON ⇒ 字节被改写)` };
+    seen.add(o);
+    try {
+        if (Array.isArray(o)) {
+            if (guard !== undefined && --guard.budget.left < 0)
+                return { bad: `${path}(超出捕获预算 ⇒ 读数过大)` };
+            const rawLen = o.length;
+            if (typeof rawLen === 'bigint' || typeof rawLen === 'symbol') {
+                return { bad: `${path}(length 是 ${typeof rawLen} ⇒ 原生序列化直接抛,归 0 会静默发空表)` };
+            }
+            let lenNum;
+            try {
+                lenNum = +rawLen;
+            }
+            catch {
+                return { bad: `${path}(length 按 ToNumber 转换即抛(BigInt/symbol 形)⇒ 原生序列化也抛,归 0 会静默发空表)` };
+            }
+            if (lenNum === Number.POSITIVE_INFINITY) {
+                return { bad: `${path}(length 是 +Infinity ⇒ 原生序列化抛 RangeError,归 0 会静默发空表)` };
+            }
+            const len = Number.isNaN(lenNum)
+                ? 0
+                : Math.min(Math.max(0, Math.trunc(lenNum)), Number.MAX_SAFE_INTEGER);
+            const items = [];
+            for (let i = 0; i < len; i++) {
+                if (guard !== undefined && --guard.budget.left < 0)
+                    return { bad: `${path}[${i}](超出捕获预算 ⇒ 读数过大)` };
+                const r = materializeJsonFaithful(o[i], `${path}[${i}]`, seen, opts);
+                if ('bad' in r)
+                    return r;
+                appendOwnElement(items, r.value);
+            }
+            return { value: items };
+        }
+        const rec = Object.create(null);
+        const fnKeys = [];
+        if (guard !== undefined && --guard.budget.left < 0)
+            return { bad: `${path}(超出捕获预算 ⇒ 读数过大)` };
+        const keys = [];
+        for (const k of Reflect.ownKeys(o)) {
+            if (typeof k !== 'string')
+                continue;
+            if (guard !== undefined && --guard.budget.left < 0)
+                return { bad: `${path}.${k}(超出捕获预算 ⇒ 读数过大)` };
+            const d = Reflect.getOwnPropertyDescriptor(o, k);
+            if (d !== undefined && d.enumerable === true)
+                appendOwnElement(keys, k);
+        }
+        for (const k of keys) {
+            const val = o[k];
+            if (val === undefined) {
+                if (opts.undefinedIsBad === true)
+                    return { bad: `${path}.${k}(值为 undefined 的键 ⇒ 不是包铸的形)` };
+                continue;
+            }
+            if (typeof val === 'function' && opts.functionLeaf !== undefined) {
+                if (guard !== undefined && --guard.budget.left < 0)
+                    return { bad: `${path}.${k}(超出捕获预算 ⇒ 读数过大)` };
+                Object.defineProperty(rec, k, { value: val, enumerable: true, writable: true, configurable: true });
+                appendOwnElement(fnKeys, k);
+                continue;
+            }
+            const r = materializeJsonFaithful(val, `${path}.${k}`, seen, opts);
+            if ('bad' in r)
+                return r;
+            Object.defineProperty(rec, k, { value: r.value, enumerable: true, writable: true, configurable: true });
+        }
+        if (guard !== undefined && --guard.budget.left < 0)
+            return { bad: `${path}(超出捕获预算 ⇒ 读数过大)` };
+        if (!isPlainRecord(o))
+            return { bad: `${path}(${shapeTag(o)})` };
+        for (const k of fnKeys)
+            if (!opts.functionLeaf(rec, k))
+                return { bad: `${path}.${k}(typeof=function 不是 JSON 值,也不在调用方认的函数位上)` };
+        return { value: rec };
+    }
+    finally {
+        seen.delete(o);
+    }
+};
+export const jsonFaithfulCost = (v) => {
+    if (v === null || typeof v !== 'object')
+        return 1;
+    if (Array.isArray(v)) {
+        let n = 3;
+        for (let i = 0; i < v.length; i++)
+            n += 1 + jsonFaithfulCost(v[i]);
+        return n;
+    }
+    let n = 4;
+    for (const k of Object.keys(v)) {
+        const val = v[k];
+        n += 1 + (val === undefined ? 0 : jsonFaithfulCost(val));
+    }
+    return n;
+};

package/dist/limitsWire.d.ts

@@ -20,7 +20,12 @@ export type LimitsParseResult = {
     ok: false;
     error: string;
 };
-export declare function parseLimitsArgv(argv: string[]): LimitsParseResult;
+export interface LimitsFlags {
+    readonly deadline?: string;
+    readonly maxTurns?: string;
+    readonly maxTokens?: string;
+}
+export declare function parseLimitsFlags(flags: LimitsFlags | undefined): LimitsParseResult;
 export declare function explicitLimitFlagNames(parsed: LimitsParseResult): string[];
 export declare function limitsSupportNotice(reading: {
     observed: boolean;
@@ -34,4 +39,4 @@ export type HeadlessEnvLimitsResult = {
     error: string;
 };
 export declare function headlessLimitsFromEnv(env?: EnvLike): HeadlessEnvLimitsResult;
-export declare function limitsForPrint(argv: string[], env?: EnvLike): LimitsParseResult;
+export declare function limitsForPrint(flags: LimitsFlags | undefined, env?: EnvLike): LimitsParseResult;

package/dist/limitsWire.js

@@ -1,5 +1,5 @@
 import { hostEnv } from './hostEnv.js';
-import { lastFlagValue } from './argvFlagValue.js';
+import { flagIsWronglyTyped, flagString } from './flagInput.js';
 import { engineVersionTier, SUPPORT_FLOOR } from './supportFloor.js';
 import { readThrownSlot } from './wireFailureShape.js';
 export const HEADLESS_DEADLINE_ENV = 'SEMA_HEADLESS_DEADLINE_SEC';
@@ -44,25 +44,31 @@ function parseIntInDomain(raw, min, max) {
 function hasAnyLimit(l) {
     return l.maxWalltimeMs !== undefined || l.maxTurns !== undefined || l.maxOutputTokens !== undefined;
 }
-export function parseLimitsArgv(argv) {
+export function parseLimitsFlags(flags) {
     const limits = {};
-    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 (flagIsWronglyTyped(flags, 'deadline'))
+        return { ok: false, error: DEADLINE_USAGE };
+    if (flagIsWronglyTyped(flags, 'maxTurns'))
+        return { ok: false, error: MAX_TURNS_USAGE };
+    if (flagIsWronglyTyped(flags, 'maxTokens'))
+        return { ok: false, error: MAX_TOKENS_USAGE };
+    const dl = flagString(flags, 'deadline');
+    if (dl !== undefined) {
+        const n = parseIntInDomain(dl, DEADLINE_SEC_MIN, DEADLINE_SEC_MAX);
         if (n === null)
             return { ok: false, error: DEADLINE_USAGE };
         limits.maxWalltimeMs = n * SEC_TO_MS;
     }
-    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;
+    const mt = flagString(flags, 'maxTurns');
+    if (mt !== undefined) {
+        const n = parseIntInDomain(mt, MAX_TURNS_MIN, MAX_TURNS_MAX);
         if (n === null)
             return { ok: false, error: MAX_TURNS_USAGE };
         limits.maxTurns = n;
     }
-    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;
+    const mk = flagString(flags, 'maxTokens');
+    if (mk !== undefined) {
+        const n = parseIntInDomain(mk, MAX_TOKENS_MIN, MAX_TOKENS_MAX);
         if (n === null)
             return { ok: false, error: MAX_TOKENS_USAGE };
         limits.maxOutputTokens = n;
@@ -139,8 +145,8 @@ export function headlessLimitsFromEnv(env = hostEnv()) {
     }
     return { ok: true, limits: hasAnyLimit(out) ? out : undefined };
 }
-export function limitsForPrint(argv, env = hostEnv()) {
-    const parsed = parseLimitsArgv(argv);
+export function limitsForPrint(flags, env = hostEnv()) {
+    const parsed = parseLimitsFlags(flags);
     if (!parsed.ok)
         return parsed;
     const fromEnv = headlessLimitsFromEnv(env);

package/dist/liveInitToolFace.d.ts

@@ -1,5 +1,6 @@
 import { type EngineProbeOpts } from './engineWireSdk.js';
 import type { EnvLike } from './hostEnv.js';
+import { type ScenarioFlag } from './scenarioWire.js';
 export declare const ENGINE_HANDS_BAND: readonly string[];
 export declare const ENGINE_SCENARIO_EXTRAS_DEFAULT: readonly string[];
 export declare const ENGINE_RUNNER_FACE: readonly string[];
@@ -15,9 +16,13 @@ export declare function probeScenarioTools(baseUrl: string, scenario: string, op
     tools: string[];
     toolset?: string;
 } | null>;
+export interface LiveInitToolFaceFlags {
+    readonly scenario?: ScenarioFlag;
+    readonly permissionMode?: string;
+}
 export interface LiveInitToolFaceOptions {
     fetchImpl?: typeof fetch;
     timeoutMs?: number;
     webSearchStamped?: boolean;
 }
-export declare function resolveLiveInitToolFace(argv: readonly string[], env: EnvLike, opts?: LiveInitToolFaceOptions): Promise<LiveInitToolFace | null>;
+export declare function resolveLiveInitToolFace(flags: LiveInitToolFaceFlags | undefined, env: EnvLike, opts?: LiveInitToolFaceOptions): Promise<LiveInitToolFace | null>;

package/dist/liveInitToolFace.js

@@ -3,6 +3,7 @@ import { settleWithinDeadline } from './abortableSleep.js';
 import { hostLog } from './host.js';
 import { scenarioForPrint } from './scenarioWire.js';
 import { resolveHeadlessInteractiveTools } from './interactiveToolsWire.js';
+import { flagObject, flagString } from './flagInput.js';
 import { webSearchVerdictFromEnv } from './webSearchWireCaps.js';
 export const ENGINE_HANDS_BAND = [
     'Bash',
@@ -101,14 +102,14 @@ export async function probeScenarioTools(baseUrl, scenario, opts) {
         return null;
     }
 }
-export async function resolveLiveInitToolFace(argv, env, opts) {
+export async function resolveLiveInitToolFace(flags, env, opts) {
     const baseUrl = env.SEMA_LIVE_BASEURL;
     if (!baseUrl)
         return null;
     try {
         let scenario;
         try {
-            const sc = scenarioForPrint([...argv], env);
+            const sc = scenarioForPrint(flagObject(flags, 'scenario'), env);
             if (sc.ok && sc.scenario)
                 scenario = sc.scenario;
         }
@@ -116,7 +117,8 @@ export async function resolveLiveInitToolFace(argv, env, opts) {
         }
         let askUserQuestion = false;
         try {
-            const r = resolveHeadlessInteractiveTools([...argv], env);
+            const mode = flagString(flags, 'permissionMode');
+            const r = resolveHeadlessInteractiveTools(mode !== undefined ? { permissionMode: mode } : undefined, env);
             askUserQuestion = r.fields.interactiveTools !== false;
         }
         catch {

package/dist/liveModelCatalog.d.ts

@@ -30,6 +30,10 @@ export declare function getLiveModelCatalog(): LiveModelCatalog | null;
 export declare function normalizeLiveModelRef(ref: string): string;
 export type ImageVision = 'yes' | 'no' | 'unknown';
 export declare function imageVisionOf(model: string | undefined, catalog?: LiveModelCatalog | null): ImageVision;
+export declare function imageVisionReadingOf(model: string | undefined, catalog?: LiveModelCatalog | null): {
+    readonly vision: ImageVision;
+    readonly model?: string;
+};
 export type EffortLevelsReading = {
     readonly kind: 'clamped';
     readonly levels: readonly string[];
@@ -44,6 +48,24 @@ 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;
+export type ModelAcceptanceReading = {
+    readonly verdict: 'accepted';
+    readonly why: 'listed';
+    readonly model: string;
+    readonly defaultModel?: string;
+} | {
+    readonly verdict: 'refused';
+    readonly why: 'not_listed' | 'disabled';
+    readonly model: string;
+    readonly defaultModel?: string;
+} | {
+    readonly verdict: 'unknown';
+    readonly why: 'catalog_absent' | 'catalog_unreadable' | 'catalog_incomplete' | 'model_absent' | 'reserved_word';
+    readonly model?: string;
+    readonly defaultModel?: string;
+};
+export declare function modelAcceptanceOf(model: string | undefined, catalog?: LiveModelCatalog | null): ModelAcceptanceReading;
+export declare function modelNotServedNotice(reading: ModelAcceptanceReading, lang?: UiLanguage): string | undefined;
 type SdkModelsListResult = Awaited<ReturnType<AgentClient['models']['list']>>;
 type SdkDroppedEntry = SdkModelsListResult extends {
     droppedEntries?: ReadonlyArray<infer E>;