@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/hostTurnSettings.js

@@ -0,0 +1,291 @@
+import { SETTINGS_CLASSIFY_HOOKS_CONFIG } from './generated/settingsSchemaFns.js';
+import { hooksWirePlanShapeOf } from './pluginHooksWire.js';
+export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle']);
+export const HOST_SETTING_CAUSES = Object.freeze([
+    'carried',
+    'entries_dropped',
+    'source_rejected',
+    'projection_failed',
+    'source_unreadable',
+    'empty',
+    'no_source',
+    'host_port_missing',
+]);
+export const HOST_SETTING_DISPOSITIONS = Object.freeze(['carry', 'carry_partial', 'withhold_notice', 'refuse_turn', 'unwired', 'nothing_to_carry']);
+const HOST_SETTING_NOTICE_TEXT = {
+    'HS-UNWIRED': (what) => `This app has not connected ${what} from your settings, so it is not sent with your requests.`,
+    'HS-MANAGED-REJECTED': () => 'Managed settings: the hooks your administrator configured could not be loaded, so requests are not sent until the managed settings are fixed.',
+    'HS-PROJECTION': () => 'The hooks for this request could not be checked before sending, so the request is not sent. Reload your settings and try again.',
+    'HS-SOURCE-UNREADABLE': (what) => `This app could not read ${what} from your settings, so the request is not sent. Reload your settings and try again.`,
+};
+const KEY_NOUN = {
+    'settings.hooks': 'the hooks',
+    'settings.resolved': 'the permission rules',
+    'settings.webSearch': 'the web search setup',
+    'settings.outputStyle': 'the output style',
+};
+const BASE_DISPOSITION = {
+    carried: 'carry',
+    entries_dropped: 'carry_partial',
+    source_rejected: 'withhold_notice',
+    projection_failed: 'refuse_turn',
+    source_unreadable: 'refuse_turn',
+    empty: 'nothing_to_carry',
+    no_source: 'nothing_to_carry',
+    host_port_missing: 'unwired',
+};
+const freeze = (o) => Object.freeze(o);
+const mint = (o) => o;
+const notice = (id, plane, what = '') => freeze({ id, plane, text: HOST_SETTING_NOTICE_TEXT[id](what) });
+function readSource(sources, key) {
+    try {
+        if (typeof sources !== 'object' || sources === null || !Object.hasOwn(sources, key))
+            return { kind: 'missing' };
+        const v = sources[key];
+        return v === undefined ? { kind: 'missing' } : { kind: 'value', value: v };
+    }
+    catch {
+        return { kind: 'threw' };
+    }
+}
+function unwrap(v, field) {
+    if (v === 'none')
+        return { kind: 'none' };
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v) || !Object.hasOwn(v, field))
+            return { kind: 'bad' };
+        return { kind: 'value', value: v[field] };
+    }
+    catch {
+        return { kind: 'bad' };
+    }
+}
+const isRecordShape = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function hooksPassJudge(wire) {
+    try {
+        return isRecordShape(wire) && SETTINGS_CLASSIFY_HOOKS_CONFIG({ hooks: wire }).outcome === 'loaded';
+    }
+    catch {
+        return false;
+    }
+}
+function badSource(key, want) {
+    return new TypeError(`hostTurnSettings: sources.${key.replace(/^settings\./, '')} must be 'none' or ${want} — got something else (the value is not echoed).`);
+}
+const missingArm = (key) => ({
+    row: freeze({ key, cause: 'host_port_missing', disposition: BASE_DISPOSITION.host_port_missing }),
+    notices: [notice('HS-UNWIRED', 'session', KEY_NOUN[key])],
+});
+const unreadableArm = (key) => ({
+    row: freeze({ key, cause: 'source_unreadable', disposition: BASE_DISPOSITION.source_unreadable }),
+    notices: [notice('HS-SOURCE-UNREADABLE', 'turn', KEY_NOUN[key])],
+});
+const noSourceArm = (key) => ({ row: freeze({ key, cause: 'no_source', disposition: BASE_DISPOSITION.no_source }), notices: [] });
+const carriedArm = (key, value) => ({ row: freeze({ key, cause: 'carried', disposition: BASE_DISPOSITION.carried }), notices: [], carried: value });
+function hooksArm(src) {
+    const key = 'settings.hooks';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const u = unwrap(src.value, 'plan');
+    if (u.kind === 'none')
+        return noSourceArm(key);
+    if (u.kind === 'bad' || hooksWirePlanShapeOf(u.value) !== 'plan')
+        throw badSource(key, '{ plan } with the plan returned by hooksWirePlan() for this turn');
+    const plan = u.value;
+    let wire;
+    let salvageRows;
+    let closedBy;
+    try {
+        wire = plan.wire;
+        salvageRows = plan.settingsSalvage;
+        closedBy = plan.closedBy;
+    }
+    catch {
+        throw badSource(key, '{ plan } with a readable plan');
+    }
+    const rows = Array.isArray(salvageRows) ? salvageRows : [];
+    const layersOf = (outcome) => rows.filter((r) => isRecordShape(r) && r.outcome === outcome && typeof r.source === 'string').map((r) => r.source);
+    const managedRejected = layersOf('rejected').includes('policySettings');
+    if (managedRejected || layersOf('loaded-partial').includes('policySettings')) {
+        return {
+            row: freeze({ key, cause: managedRejected ? 'source_rejected' : 'entries_dropped', disposition: 'refuse_turn', layers: freeze(['policySettings']) }),
+            notices: [notice('HS-MANAGED-REJECTED', 'turn')],
+            plan,
+        };
+    }
+    if (closedBy === 'governance_unreadable')
+        return { ...unreadableArm(key), plan };
+    if (wire !== undefined && !hooksPassJudge(wire)) {
+        return { row: freeze({ key, cause: 'projection_failed', disposition: BASE_DISPOSITION.projection_failed }), notices: [notice('HS-PROJECTION', 'turn')], plan };
+    }
+    const carried = wire === undefined ? undefined : wire;
+    const rejected = layersOf('rejected');
+    const partial = layersOf('loaded-partial');
+    if (rejected.length > 0 || partial.length > 0) {
+        const cause = rejected.length > 0 ? 'source_rejected' : 'entries_dropped';
+        const layers = freeze([...new Set([...rejected, ...partial])]);
+        return { row: freeze({ key, cause, disposition: carried !== undefined ? 'carry_partial' : 'withhold_notice', layers }), notices: [], carried, plan };
+    }
+    if (carried === undefined)
+        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [], plan };
+    return { ...carriedArm(key, carried), plan };
+}
+function passArm(key, field, src, want) {
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const u = unwrap(src.value, field);
+    if (u.kind === 'none')
+        return noSourceArm(key);
+    if (u.kind === 'bad')
+        throw badSource(key, want);
+    if (u.value === undefined || u.value === null)
+        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+    return carriedArm(key, u.value);
+}
+const RESOLVED_DEFERRED_ERROR = Symbol('hostTurnSettings.resolvedDeferredError');
+export function rethrowHostResolvedDeferred(product) {
+    const rec = product;
+    if (!Object.hasOwn(rec, RESOLVED_DEFERRED_ERROR))
+        return;
+    const box = rec[RESOLVED_DEFERRED_ERROR];
+    if (box !== undefined)
+        throw box.error;
+}
+export function buildHostTurnSettings(input, materialize) {
+    let sources;
+    let sourcesThrew = false;
+    try {
+        sources = input?.sources;
+    }
+    catch {
+        sourcesThrew = true;
+    }
+    const read = (key) => (sourcesThrew ? { kind: 'threw' } : readSource(sources, key));
+    const resolved = passArm('settings.resolved', 'snapshot', read('resolved'), '{ snapshot } with the resolver snapshot');
+    let resolvedCarried = resolved.carried;
+    let resolvedError;
+    if (resolvedCarried !== undefined) {
+        try {
+            resolvedCarried = materialize(resolvedCarried);
+        }
+        catch (error) {
+            resolvedError = freeze({ error });
+        }
+    }
+    const hooks = hooksArm(read('hooks'));
+    const webSearch = passArm('settings.webSearch', 'settings', read('webSearch'), '{ settings } with the web search settings');
+    const outputStyle = passArm('settings.outputStyle', 'name', read('outputStyle'), '{ name } with the output style name');
+    const arms = [hooks, resolved, webSearch, outputStyle];
+    const rows = freeze(arms.map((a) => a.row));
+    const notices = freeze(arms.flatMap((a) => a.notices));
+    const refusal = arms.find((a) => a.row.disposition === 'refuse_turn');
+    const verdict = refusal === undefined ? freeze({ kind: 'send' }) : freeze({ kind: 'refuse', notice: refusal.notices[0] ?? notice('HS-PROJECTION', 'turn') });
+    const carried = freeze({
+        ...(hooks.carried !== undefined ? { hooks: hooks.carried } : {}),
+        ...(resolvedCarried !== undefined ? { resolved: resolvedCarried } : {}),
+        ...(webSearch.carried !== undefined ? { webSearch: webSearch.carried } : {}),
+        ...(outputStyle.carried !== undefined ? { outputStyle: outputStyle.carried } : {}),
+    });
+    const product = { verdict, rows, notices, hooks: hooks.plan, carried };
+    if (resolvedError !== undefined)
+        Object.defineProperty(product, RESOLVED_DEFERRED_ERROR, { value: resolvedError, enumerable: false });
+    return mint(freeze(product));
+}
+export function hostSettingsSelfCheck(product) {
+    try {
+        const rows = product.rows;
+        if (!Array.isArray(rows))
+            return HOST_SUPPLIED_KEYS;
+        const seen = new Set();
+        const out = [];
+        for (const r of rows) {
+            if (!isRecordShape(r) || typeof r.key !== 'string')
+                continue;
+            seen.add(r.key);
+            if (r.disposition === 'unwired' && HOST_SUPPLIED_KEYS.includes(r.key))
+                out.push(r.key);
+        }
+        for (const k of HOST_SUPPLIED_KEYS)
+            if (!seen.has(k) && !out.includes(k))
+                out.push(k);
+        return freeze(out);
+    }
+    catch {
+        return HOST_SUPPLIED_KEYS;
+    }
+}
+export class HostSettingsRefused extends Error {
+    notice;
+    constructor(n) {
+        super(n.text);
+        this.name = 'HostSettingsRefused';
+        this.notice = n;
+    }
+}
+const CARRYING = new Set(['carry', 'carry_partial']);
+function shapeOf(v) {
+    if (v === undefined || v === null)
+        return UNWIRED_HOST_TURN_SETTINGS;
+    try {
+        if (!isRecordShape(v))
+            return undefined;
+        for (const k of ['verdict', 'rows', 'notices', 'hooks', 'carried'])
+            if (!Object.hasOwn(v, k))
+                return undefined;
+        const rows = v.rows;
+        if (!Array.isArray(rows) || rows.length !== HOST_SUPPLIED_KEYS.length)
+            return undefined;
+        const keys = rows.map((r) => (isRecordShape(r) ? r.key : undefined));
+        if (!HOST_SUPPLIED_KEYS.every((k, i) => keys[i] === k))
+            return undefined;
+        if (!isRecordShape(v.carried) || !isRecordShape(v.verdict))
+            return undefined;
+        const product = v;
+        return product;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hostTurnSettingsOf(v, depth = 'full') {
+    const shaped = shapeOf(v);
+    if (depth === 'shape' || shaped === undefined || shaped === UNWIRED_HOST_TURN_SETTINGS)
+        return shaped;
+    try {
+        const view = shaped;
+        const p = view;
+        const rows = p.rows;
+        const carried = p.carried;
+        const subs = HOST_SUPPLIED_KEYS.map((k) => k.slice('settings.'.length));
+        if (Object.keys(carried).some((k) => !subs.includes(k)))
+            return undefined;
+        let refuses = false;
+        for (const [i, r] of rows.entries()) {
+            const disposition = r.disposition;
+            if (!HOST_SETTING_DISPOSITIONS.includes(disposition))
+                return undefined;
+            if (disposition === 'refuse_turn')
+                refuses = true;
+            const sub = subs[i] ?? '';
+            const has = Object.hasOwn(carried, sub) && carried[sub] !== undefined;
+            if (has !== CARRYING.has(disposition))
+                return undefined;
+        }
+        const verdict = p.verdict;
+        if (verdict.kind !== (refuses ? 'refuse' : 'send'))
+            return undefined;
+        if (refuses && !(isRecordShape(verdict.notice) && typeof verdict.notice.text === 'string'))
+            return undefined;
+        if (Object.hasOwn(carried, 'hooks') && carried.hooks !== undefined && !hooksPassJudge(carried.hooks))
+            return undefined;
+        return shaped;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const UNWIRED_HOST_TURN_SETTINGS = buildHostTurnSettings({ sources: {} }, (snapshot) => snapshot);

package/dist/humanTurn.d.ts

@@ -1,6 +1,8 @@
+import type { UserAttachment } from '@sema-agent/sdk';
 import type { ImageInput } from './imagesWireCaps.js';
 import type { ImageVision } from './liveModelCatalog.js';
 import { type UserAttachmentDescriptor } from './userAttachmentEnvelope.js';
+import type { UserAttachmentSeatReading } from './userAttachmentSeat.js';
 export interface HumanTurnRider {
     readonly uuid: string;
     readonly role: 'image_meta' | 'attachment' | 'skill_body' | (string & {});
@@ -34,6 +36,7 @@ export interface HumanTurnItem {
 }
 export interface HumanTurnCaps {
     readonly vision?: ImageVision;
+    readonly userAttachments?: UserAttachmentSeatReading;
 }
 export interface HumanTurnInput {
     readonly items: readonly HumanTurnItem[];
@@ -41,7 +44,7 @@ export interface HumanTurnInput {
     readonly caps: HumanTurnCaps;
     readonly otherBodyBytes?: number;
 }
-type EncoderShortfall = 'body_budget' | 'steer_admission' | 'vision_no' | 'vision_unknown' | 'image_too_large' | 'seat_count' | 'seat_total' | 'lane_has_no_image_seat' | 'lane_has_no_attachment_id_seat';
+type EncoderShortfall = 'body_budget' | 'steer_admission' | 'vision_no' | 'image_too_large' | 'seat_count' | 'seat_total' | 'lane_has_no_image_seat' | 'lane_has_no_attachment_id_seat';
 export interface HumanTurnSharePart {
     readonly kind: 'text' | 'image' | 'attachment_ref' | 'attachment_id' | 'rider_text' | 'non_text';
     readonly ref?: string | number;
@@ -60,14 +63,23 @@ export interface HumanTurnDegraded {
     readonly ref?: string | number;
     readonly why: EncoderShortfall;
 }
+export interface HumanTurnNotice {
+    readonly uuid: string;
+    readonly kind: 'image';
+    readonly ref: string;
+    readonly why: 'vision_unknown';
+}
 export type HumanTurnEncoding = {
     readonly ok: true;
     readonly lane: 'objective';
     readonly text: string;
     readonly images: readonly ImageInput[];
     readonly attachmentIds: readonly string[];
+    readonly userAttachments?: readonly UserAttachment[];
+    readonly userAttachmentOrdinals?: readonly string[];
     readonly shares: readonly HumanTurnShare[];
     readonly degraded: readonly HumanTurnDegraded[];
+    readonly notices?: readonly HumanTurnNotice[];
 } | {
     readonly ok: true;
     readonly lane: 'steer';
@@ -86,6 +98,7 @@ export interface HumanTurnDelivered {
     readonly full: readonly string[];
     readonly partial: readonly string[];
 }
+export declare function imageSentOnUnknownVision(notices: readonly HumanTurnNotice[] | undefined): string | undefined;
 export declare function encodeHumanTurn(input: HumanTurnInput): HumanTurnEncoding;
 export declare function deliveredUuidsOf(encoding: HumanTurnEncoding): HumanTurnDelivered;
 export {};

package/dist/humanTurn.js

@@ -1,5 +1,5 @@
-import { CORE_MAX_PENDING_STEER_CHARS, CORE_MCP_IMAGE_MAX_BASE64 } from './generated/engineFactTables.js';
-import { mintEnvelopeOf, mintReferenceOf } from './userAttachmentEnvelope.js';
+import { CORE_MAX_PENDING_STEER_CHARS, CORE_MCP_IMAGE_MAX_BASE64, CORE_USER_ATTACHMENT_LABEL_MAX } from './generated/engineFactTables.js';
+import { mintEnvelopeOf, mintReferenceOf, seatTextOf } from './userAttachmentEnvelope.js';
 import { readEncodingShares, readHumanTurnInput } from './humanTurnRead.js';
 const REQUEST_BODY_MAX_BYTES = 8 * 1024 * 1024;
 const IMAGE_SEAT_MAX_COUNT = 20;
@@ -29,12 +29,14 @@ function utf8Length(s) {
     return n;
 }
 const jsonBytes = (v) => utf8Length(JSON.stringify(v));
-function bodyBytes(other, objective, images, ids) {
+function bodyBytes(other, objective, images, ids, entries) {
     const keys = [jsonBytes('objective') + 1 + jsonBytes(objective)];
     if (images.length > 0)
         keys.push(jsonBytes('images') + 1 + jsonBytes(images));
     if (ids.length > 0)
         keys.push(jsonBytes('attachmentIds') + 1 + jsonBytes(ids));
+    if (entries.length > 0)
+        keys.push(jsonBytes('userAttachments') + 1 + jsonBytes(entries));
     const commas = other === 2 ? keys.length - 1 : keys.length;
     return other + keys.reduce((a, b) => a + b, 0) + commas;
 }
@@ -52,8 +54,27 @@ function steerRefusal(text) {
 function textOf(p) {
     if (p.form === 'reference')
         return mintReferenceOf(p.a.d);
+    if (p.form === 'seat')
+        return '';
     return mintEnvelopeOf(p.a.d, p.seated ? 'attached' : 'not-attached');
 }
+const digits = (n) => String(n).length;
+function renderedUpperBound(text, startLine) {
+    const lines = text.split('\n').length;
+    return text.length + lines * (digits(startLine + lines - 1) + 1);
+}
+function seatEntryOf(a, maxRenderedTextChars) {
+    const text = seatTextOf(a.d);
+    if (text === undefined || !('path' in a.d))
+        return undefined;
+    const name = a.d.path;
+    if (name.length === 0 || name.length > CORE_USER_ATTACHMENT_LABEL_MAX)
+        return undefined;
+    const startLine = a.d.kind === 'text' ? a.d.startLine : 1;
+    if (renderedUpperBound(text, startLine) > maxRenderedTextChars)
+        return undefined;
+    return a.d.kind === 'text' ? { name, text, startLine } : { name, text };
+}
 function compose(items, placements) {
     const perItem = items.map((it, i) => [...placements.filter((p) => p.item === i).map(textOf), it.text].filter((s) => s.length > 0).join('\n\n'));
     return perItem.filter((s) => s.length > 0).join('\n');
@@ -76,7 +97,6 @@ const ENCODER_WHY_LIST = [
     'body_budget',
     'steer_admission',
     'vision_no',
-    'vision_unknown',
     'image_too_large',
     'seat_count',
     'seat_total',
@@ -101,7 +121,7 @@ function records(lane, items, pastedWhy, placements) {
         for (const p of placements) {
             if (p.item !== i)
                 continue;
-            push(i, p.form === 'content' ? { kind: 'attachment_ref', ref: p.a.uuid, status: 'full' } : { kind: 'attachment_ref', ref: p.a.uuid, status: 'none', why: lane === 'objective' ? 'body_budget' : 'steer_admission' });
+            push(i, p.form !== 'reference' ? { kind: 'attachment_ref', ref: p.a.uuid, status: 'full' } : { kind: 'attachment_ref', ref: p.a.uuid, status: 'none', why: lane === 'objective' ? 'body_budget' : 'steer_admission' });
             if (p.a.pixels !== undefined) {
                 if (lane === 'steer')
                     push(i, { kind: 'image', ref: p.a.uuid, status: 'none', why: 'lane_has_no_image_seat' });
@@ -142,6 +162,33 @@ function sharesAndDegraded(items, recs) {
     }
     return { shares, degraded };
 }
+function noticesKey(v, items, placements) {
+    if (v.vision !== 'unknown')
+        return {};
+    const notices = [];
+    for (const p of placements) {
+        if (p.form === 'content' && p.seated && p.a.pixels !== undefined)
+            notices.push({ uuid: items[p.item].uuid, kind: 'image', ref: p.a.uuid, why: 'vision_unknown' });
+    }
+    return notices.length > 0 ? { notices } : {};
+}
+export function imageSentOnUnknownVision(notices) {
+    let n = 0;
+    try {
+        if (!Array.isArray(notices))
+            return undefined;
+        for (const x of notices)
+            if (x !== null && typeof x === 'object' && x.why === 'vision_unknown')
+                n += 1;
+    }
+    catch {
+        return undefined;
+    }
+    if (n === 0)
+        return undefined;
+    const what = n === 1 ? 'An @-mentioned image was' : `${n} @-mentioned images were`;
+    return `${what} sent with this message, although the engine's model list does not say whether the model this message uses accepts image input — if it does not, the images may be dropped or the message may be refused`;
+}
 function encodeObjective(v) {
     const { items } = v;
     let count = 0;
@@ -161,10 +208,10 @@ function encodeObjective(v) {
     const placements = [];
     items.forEach((it, i) => {
         for (const a of it.attachments) {
-            const p = { item: i, a, form: 'content', seated: false, seatWhy: undefined };
+            const p = { item: i, a, form: 'content', seated: false, seatWhy: undefined, entry: undefined };
             if (a.pixels !== undefined) {
-                if (v.vision !== 'yes')
-                    p.seatWhy = v.vision === 'no' ? 'vision_no' : 'vision_unknown';
+                if (v.vision === 'no')
+                    p.seatWhy = 'vision_no';
                 else {
                     p.seatWhy = seat(a.pixels.data.length);
                     p.seated = p.seatWhy === undefined;
@@ -173,21 +220,62 @@ function encodeObjective(v) {
             placements.push(p);
         }
     });
+    if (v.seat !== undefined) {
+        let n = 0;
+        for (const p of placements) {
+            if (n >= v.seat.maxEntries)
+                break;
+            const entry = seatEntryOf(p.a, v.seat.maxRenderedTextChars);
+            if (entry === undefined)
+                continue;
+            p.form = 'seat';
+            p.entry = entry;
+            n += 1;
+        }
+        if (n > 0 && compose(items, placements).trim() === '') {
+            for (const p of placements) {
+                if (p.form === 'seat') {
+                    p.form = 'content';
+                    p.entry = undefined;
+                }
+            }
+        }
+    }
     const ids = items.flatMap((it) => it.attachmentIds);
     for (;;) {
         const text = compose(items, placements);
         const images = seatedImages(items, pastedWhy, placements);
-        if (bodyBytes(v.otherBodyBytes, text, images, ids) <= REQUEST_BODY_MAX_BYTES) {
+        const seated = placements.filter((p) => p.form === 'seat');
+        const entries = seated.map((p) => p.entry);
+        if (bodyBytes(v.otherBodyBytes, text, images, ids, entries) <= REQUEST_BODY_MAX_BYTES) {
             if (text.trim() === '')
                 return { ok: false, reason: 'empty' };
             const { shares, degraded } = sharesAndDegraded(items, records('objective', items, pastedWhy, placements));
-            return { ok: true, lane: 'objective', text, images, attachmentIds: [...ids], shares, degraded };
+            return {
+                ok: true,
+                lane: 'objective',
+                text,
+                images,
+                attachmentIds: [...ids],
+                ...(entries.length > 0 ? { userAttachments: entries, userAttachmentOrdinals: seated.map((p) => p.a.uuid) } : {}),
+                shares,
+                degraded,
+                ...noticesKey(v, items, placements),
+            };
         }
         let pick = -1;
         let pickCost = -1;
         placements.forEach((p, k) => {
-            if (p.form !== 'content')
+            if (p.form === 'reference')
                 return;
+            if (p.form === 'seat') {
+                const cost = jsonBytes(p.entry) + 1;
+                if (cost >= pickCost) {
+                    pick = k;
+                    pickCost = cost;
+                }
+                return;
+            }
             const cost = jsonBytes(textOf(p)) + (p.seated && p.a.pixels !== undefined ? jsonBytes({ data: p.a.pixels.data, mimeType: p.a.pixels.mimeType }) : 0);
             if (cost >= pickCost) {
                 pick = k;
@@ -204,7 +292,7 @@ function encodeSteer(v) {
     const placements = [];
     items.forEach((it, i) => {
         for (const a of it.attachments)
-            placements.push({ item: i, a, form: 'content', seated: false, seatWhy: undefined });
+            placements.push({ item: i, a, form: 'content', seated: false, seatWhy: undefined, entry: undefined });
     });
     let text = compose(items, placements);
     let refusal = steerRefusal(text);

package/dist/humanTurnRead.d.ts

@@ -2,6 +2,7 @@ import type { ImageInput } from './imagesWireCaps.js';
 import type { UserAttachmentDescriptor, UserAttachmentMcpResourcePart, UserAttachmentNotIncludedReason, UserAttachmentSource } from './userAttachmentEnvelope.js';
 import type { HumanTurnAttachment, HumanTurnEncoding, HumanTurnInput, HumanTurnMissing } from './humanTurn.js';
 import type { ImageVision } from './liveModelCatalog.js';
+import { type UserAttachmentSeatLimits } from './userAttachmentSeat.js';
 export interface CellView {
     cellType: string | undefined;
     source: string | undefined;
@@ -104,6 +105,7 @@ export interface ItemView {
 export interface InputView {
     lane: 'objective' | 'steer';
     vision: ImageVision;
+    seat: UserAttachmentSeatLimits | undefined;
     otherBodyBytes: number;
     items: ItemView[];
 }

package/dist/humanTurnRead.js

@@ -1,3 +1,4 @@
+import { userAttachmentSeatAdmits } from './userAttachmentSeat.js';
 const descriptorKindsAligned = true;
 void descriptorKindsAligned;
 const MALFORMED = Object.freeze({});
@@ -258,6 +259,25 @@ function readItem(x) {
         }),
     };
 }
+function seatLimitsOf(caps) {
+    try {
+        const reading = ownData(caps, 'userAttachments');
+        if (reading === undefined)
+            return undefined;
+        if (userAttachmentSeatAdmits(reading) !== 'yes')
+            return undefined;
+        const limits = ownData(reading, 'limits');
+        if (!isPlainObject(limits))
+            return undefined;
+        const maxEntries = ownData(limits, 'maxEntries');
+        const maxRenderedTextChars = ownData(limits, 'maxRenderedTextChars');
+        const ok = (n) => typeof n === 'number' && Number.isSafeInteger(n) && n >= 1;
+        return ok(maxEntries) && ok(maxRenderedTextChars) ? { maxEntries, maxRenderedTextChars } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function readInputAny(x) {
     if (!isPlainObject(x))
         reject('malformed_input');
@@ -271,6 +291,7 @@ function readInputAny(x) {
     const vision = ownData(caps, 'vision');
     if (vision !== undefined && vision !== 'yes' && vision !== 'no' && vision !== 'unknown')
         reject('malformed_input');
+    const seat = seatLimitsOf(caps);
     let otherBodyBytes = 0;
     if (lane === 'objective') {
         const ob = ownData(o, 'otherBodyBytes');
@@ -316,7 +337,7 @@ function readInputAny(x) {
     }
     if (items.every((it) => it.text.length === 0 && it.images.length === 0 && it.attachments.length === 0 && it.attachmentIds.length === 0))
         reject('empty');
-    return { lane: lane, vision: vision ?? 'unknown', otherBodyBytes, items };
+    return { lane: lane, vision: vision ?? 'unknown', seat, otherBodyBytes, items };
 }
 export function readHumanTurnInput(input) {
     try {