@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/permissionsDeclaration.js

@@ -1,7 +1,8 @@
-import { compileAllowList, hasCoreValuePort, protocolOf, retiredToolNames, ruleToolGrammarOf } from './coreValuePorts.js';
-import { clientOwnedServerPrefix, protocolSegmentOf } from './protocolSegment.js';
+import { compileAllowList, hasCoreValuePort, protocolOf, ruleToolGrammarOf } from './coreValuePorts.js';
+import { clientOwnedServerPrefix, mintedPrefixOf, ruleToolNameVerdictOf } from './protocolSegment.js';
 import { ruleCompileVerdict } from './ruleCompileVerdict.js';
 import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability.js';
+import { THROWN_SLOT_UNREADABLE, readThrownSlot } from './wireFailureShape.js';
 export const WIRE_RULE_TRUST_ORDER = Object.freeze([
     'policySettings',
     'cliArg',
@@ -73,22 +74,33 @@ function parseRule(rule) {
     return { toolName: normalizeLegacyToolName(toolName), ruleContent: unescapeRuleContent(rawContent) };
 }
 function requireRulePorts() {
-    const required = ['MCP_NAMESPACE', 'RETIRED_TOOL_NAMES', 'protocolOf', 'ruleToolGrammarOf', 'validatePermissionRules'];
+    const required = ['MCP_NAMESPACE', 'judgeRuleToolName', 'protocolOf', 'ruleToolGrammarOf', 'validatePermissionRules'];
     const missing = required.filter((p) => !hasCoreValuePort(p));
     if (missing.length === 0)
         return;
     throw new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
         '缺席不等于全部合格:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。');
 }
-function wireIssue(name) {
+function nameCheck(name) {
     if (name.includes('('))
-        return 'paren_in_tool_name';
-    if (retiredToolNames().has(name))
-        return 'retired_tool_name';
+        return { issue: 'paren_in_tool_name' };
+    const verdict = ruleToolNameVerdictOf(name);
+    if (verdict.kind === 'unknown') {
+        throw new Error('permissionsDeclaration: 规则工具名判官(judgeRuleToolName)答不上来(抛 / 回的不是 current · retired · unprefixed_namespace · unmintable_segment 之一)—— ' +
+            '装的必须是 core 的同名实现、原样装。判不出不等于够得着:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。');
+    }
+    if (verdict.kind === 'retired')
+        return { issue: 'retired_tool_name' };
+    if (verdict.kind === 'unprefixed_namespace')
+        return { issue: 'unprefixed_namespaced_name' };
     const ns = protocolOf(name);
-    if (ns === undefined)
-        return name.includes('__') ? 'unprefixed_namespaced_name' : undefined;
-    return ns.parse(name) !== undefined ? undefined : 'incomplete_protocol_name';
+    if (ns !== undefined && ns.parse(name) === undefined)
+        return { issue: 'incomplete_protocol_name' };
+    if (verdict.kind === 'unmintable_segment') {
+        const minted = mintedPrefixOf(name);
+        return { unminted: minted !== undefined ? { minted } : {} };
+    }
+    return { ok: true };
 }
 function wholeServerRuleName(name) {
     const read = name.trim();
@@ -100,11 +112,16 @@ function wholeServerRuleName(name) {
 }
 const compileVerdict = ruleCompileVerdict;
 const kept = (reason) => ({ sent: false, reason });
-function sentFate(wire, toolName, unchecked) {
-    const segment = protocolSegmentOf(toolName);
-    return segment.kind === 'unminted'
-        ? { sent: true, wire, unchecked, unreachable: segment.minted !== undefined ? { minted: segment.minted } : {} }
-        : { sent: true, wire, unchecked };
+function compileRefused(verdict) {
+    return {
+        sent: false,
+        reason: 'compile_refused',
+        ...(verdict.code !== undefined ? { code: verdict.code } : {}),
+        ...(verdict.message !== undefined ? { message: verdict.message } : {}),
+    };
+}
+function sentFate(wire, check, unchecked) {
+    return 'unminted' in check ? { sent: true, wire, unchecked, unreachable: check.unminted } : { sent: true, wire, unchecked };
 }
 function judgeList(rules, behavior, allowForm = 'grant') {
     let portsChecked = false;
@@ -118,42 +135,34 @@ function judgeList(rules, behavior, allowForm = 'grant') {
         const parsed = parseRule(rule);
         if (parsed.ruleContent === undefined) {
             const name = wholeServerRuleName(parsed.toolName);
-            const issue = wireIssue(name);
-            if (issue !== undefined)
-                return kept(issue);
-            if (behavior === 'allow') {
-                const segment = protocolSegmentOf(name);
-                if (segment.kind === 'unminted')
-                    return kept('unminted_protocol_segment');
-                if (segment.kind === 'unknown')
-                    return kept('judge_failed');
-            }
+            const check = nameCheck(name);
+            if ('issue' in check)
+                return kept(check.issue);
+            if (behavior === 'allow' && 'unminted' in check)
+                return kept('unminted_protocol_segment');
             const verdict = compileVerdict(name, behavior === 'ask' ? 'ask' : 'deny');
-            if (verdict === 'refused')
-                return kept('compile_refused');
-            if (verdict === 'unknown' && behavior === 'allow')
+            if (verdict.kind === 'refused')
+                return compileRefused(verdict);
+            if (verdict.kind === 'unknown' && behavior === 'allow')
                 return kept('judge_failed');
-            return behavior === 'allow' ? { sent: true, wire: name, unchecked: false } : sentFate(name, name, verdict === 'unknown');
+            return behavior === 'allow' ? { sent: true, wire: name, unchecked: false } : sentFate(name, check, verdict.kind === 'unknown');
         }
-        const issue = wireIssue(parsed.toolName);
-        if (issue !== undefined)
-            return kept(issue);
+        const check = nameCheck(parsed.toolName);
+        if ('issue' in check)
+            return kept(check.issue);
         if (ruleToolGrammarOf(parsed.toolName) === 'path' && parsed.ruleContent.startsWith('~/'))
             return kept('home_relative_path');
         if (behavior === 'allow') {
             if (allowForm !== 'layer')
                 return kept('content_form_not_grantable');
-            const segment = protocolSegmentOf(parsed.toolName);
-            if (segment.kind === 'unminted')
+            if ('unminted' in check)
                 return kept('unminted_protocol_segment');
-            if (segment.kind === 'unknown')
-                return kept('judge_failed');
             return { sent: true, wire: rule, unchecked: false };
         }
         const verdict = compileVerdict(rule, behavior);
-        if (verdict === 'refused')
-            return kept('compile_refused');
-        return sentFate(rule, parsed.toolName, verdict === 'unknown');
+        if (verdict.kind === 'refused')
+            return compileRefused(verdict);
+        return sentFate(rule, check, verdict.kind === 'unknown');
     });
 }
 function outsideSettingsFiles(origin) {
@@ -369,8 +378,15 @@ function assemble(input, caps) {
     for (const [bucket, slots, j] of rows) {
         slots.forEach((s, k) => {
             const f = j.fates[k];
-            if (!f.sent)
-                keptRows.push({ rule: s.rule, bucket, reason: f.reason });
+            if (!f.sent) {
+                keptRows.push({
+                    rule: s.rule,
+                    bucket,
+                    reason: f.reason,
+                    ...(f.code !== undefined ? { code: f.code } : {}),
+                    ...(f.message !== undefined ? { message: f.message } : {}),
+                });
+            }
         });
         for (const wire of j.sent) {
             const winner = j.winnerOf.get(wire);
@@ -396,3 +412,47 @@ export function permissionsDeclarationReport(input, caps) {
     const { buckets, report } = assemble(input, caps);
     return { ...(Object.keys(buckets).length > 0 ? { permissions: buckets } : {}), ...report };
 }
+const ALLOW_KEPT_ROWS_READ_MAX = 4096;
+function allowHeldBySettingsReadCount(report) {
+    if (typeof report !== 'object' || report === null)
+        return 0;
+    const kept = readThrownSlot(report, 'kept');
+    if (typeof kept !== 'object' || kept === null)
+        return 0;
+    const length = readThrownSlot(kept, 'length');
+    if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0)
+        return 0;
+    let n = 0;
+    for (let i = 0; i < Math.min(length, ALLOW_KEPT_ROWS_READ_MAX); i++) {
+        const row = readThrownSlot(kept, String(i));
+        if (typeof row === 'object' && row !== null && readThrownSlot(row, 'reason') === 'settings_read_not_clean')
+            n++;
+    }
+    return n;
+}
+export function permissionsAllowKeptNotice(report, settingsRead, facts) {
+    const held = allowHeldBySettingsReadCount(report);
+    if (held <= 0)
+        return undefined;
+    const readFact = (key) => {
+        if (typeof facts !== 'object' || facts === null)
+            return undefined;
+        const v = readThrownSlot(facts, key);
+        return v === THROWN_SLOT_UNREADABLE ? undefined : v;
+    };
+    const rawCount = readFact('problemCount');
+    const rawWhere = readFact('where');
+    const managedPending = readFact('managedPolicyPending') === true;
+    const count = typeof rawCount === 'number' && Number.isInteger(rawCount) && rawCount >= 1 ? rawCount : undefined;
+    const where = typeof rawWhere === 'string' && rawWhere.length >= 1 && rawWhere.length <= 200 && !/\p{Cc}/u.test(rawWhere) ? rawWhere : undefined;
+    const head = `${String(held)} permissions.allow rule${held === 1 ? ' was' : 's were'} not sent to the engine for this run because `;
+    if (settingsRead === 'partial' && managedPending && count === 1) {
+        return (`${head}the managed policy for your account has not been received yet (sema keeps fetching it; allow rules apply once it arrives). ` +
+            'Run again once it has been received (deny and ask rules, and rules given with --allowedTools, are still sent).');
+    }
+    const why = settingsRead === 'partial'
+        ? `the settings read reported ${count === undefined ? 'problems' : `${String(count)} problem${count === 1 ? '' : 's'}`}${where === undefined ? '' : ` (${where})`}`
+        : 'the health of this settings read could not be checked';
+    return (`${head}${why}; an allow rule from a settings file is only sent from a settings read with no problems. Fix the reported settings, then run again ` +
+        '(deny and ask rules from this read, and rules given with --allowedTools, are still sent).');
+}

package/dist/printPermissionOutcome.d.ts

@@ -0,0 +1,12 @@
+import { type GateOutcomeView } from './gateOutcome.js';
+import { type NoticeOutlet, type NoticeSeatClass } from './noticePresentation.js';
+export declare const PRINT_PERMISSION_OUTCOME_FORMS: readonly ["mode_denied", "no_approver", "mode_released"];
+export type PrintPermissionOutcomeForm = (typeof PRINT_PERMISSION_OUTCOME_FORMS)[number];
+export interface PrintPermissionOutcome {
+    readonly form: PrintPermissionOutcomeForm;
+    readonly sentence: string;
+    readonly audience: 'user';
+    readonly outlet: NoticeOutlet;
+    readonly seatClass: NoticeSeatClass;
+}
+export declare function printPermissionOutcomeOf(gate: GateOutcomeView | undefined): PrintPermissionOutcome | undefined;

package/dist/printPermissionOutcome.js

@@ -0,0 +1,50 @@
+import { modeReleaseReasonSentence } from './gateOutcome.js';
+import { noticeSeatClassOf } from './noticePresentation.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+export const PRINT_PERMISSION_OUTCOME_FORMS = Object.freeze(['mode_denied', 'no_approver', 'mode_released']);
+const ALLOW_RULE_REMEDY = 'add an allow rule for the tool in settings (or pass --allowedTools)';
+const SENTENCES = Object.freeze({
+    dontAsk: {
+        sentence: `the dontAsk permission mode denies tools that need approval unless a permission rule allows them — ${ALLOW_RULE_REMEDY}`,
+        outlet: 'present',
+    },
+    bypassPermissions: {
+        sentence: 'the bypassPermissions permission mode refused a call because it could not tell whether the write it makes lands on a protected path',
+        outlet: 'absent',
+    },
+    mode: { sentence: "the session's permission mode denied a call that needed approval", outlet: 'absent' },
+    no_approver: {
+        sentence: `print mode has no approval channel: tools that need approval are denied unless a permission rule allows them — ${ALLOW_RULE_REMEDY}, or pass --permission-mode acceptEdits or auto`,
+        outlet: 'present',
+    },
+});
+function outcomeOf(form, sentence, outlet) {
+    return Object.freeze({ form, sentence, audience: 'user', outlet, seatClass: noticeSeatClassOf('user', outlet) });
+}
+function slot(from, key) {
+    return typeof from === 'object' && from !== null ? guardedRead(() => readOwnDataValue(from, key)) : undefined;
+}
+export function printPermissionOutcomeOf(gate) {
+    const disposition = slot(gate, 'disposition');
+    const kind = slot(disposition, 'kind');
+    if (kind === 'denied') {
+        const deniedBy = slot(disposition, 'deniedBy');
+        if (deniedBy === 'mode') {
+            const mode = slot(disposition, 'mode');
+            const row = mode === 'dontAsk' ? SENTENCES.dontAsk : mode === 'bypassPermissions' ? SENTENCES.bypassPermissions : SENTENCES.mode;
+            return outcomeOf('mode_denied', row.sentence, row.outlet);
+        }
+        if (deniedBy === 'ask_resolution') {
+            const settled = slot(slot(gate, 'settlement'), 'kind');
+            if (settled === 'no_approver' || settled === 'approver_unavailable')
+                return outcomeOf('no_approver', SENTENCES.no_approver.sentence, SENTENCES.no_approver.outlet);
+        }
+        return undefined;
+    }
+    if (kind === 'allowed') {
+        const reason = slot(slot(disposition, 'released'), 'reason');
+        const sentence = typeof reason === 'string' ? modeReleaseReasonSentence(reason) : undefined;
+        return sentence === undefined ? undefined : outcomeOf('mode_released', sentence, 'absent');
+    }
+    return undefined;
+}

package/dist/printToolResultFrame.d.ts

@@ -13,6 +13,7 @@ export interface ToolEndResultArmLike {
     delivered?: unknown;
     gatedCallId?: unknown;
     _sema_denial_kind?: unknown;
+    notExecuted?: true;
     parentToolCallId?: unknown;
     uuid?: unknown;
     session_id?: unknown;

package/dist/printToolResultFrame.js

@@ -1,22 +1,8 @@
 import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
-import { parseModelFacingBash } from './toolResult.js';
 import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
-function bashExitCodeFailed(toolName, text, structured) {
-    if (typeof toolName !== 'string' || toolName.toLowerCase() !== 'bash')
-        return false;
-    const st = structured;
-    if (typeof st?.returnCodeInterpretation === 'string' && st.returnCodeInterpretation.length > 0)
-        return false;
-    const ec = st?.exitCode;
-    if (typeof ec === 'number')
-        return ec !== 0;
-    if (parseModelFacingBash(text)?.note !== undefined)
-        return false;
-    const m = /^exit code: (\d+)\b/.exec(text);
-    return m !== null && m[1] !== '0';
-}
+import { readFrameTrueMark } from './ownKey.js';
 export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)
         return null;
@@ -29,6 +15,7 @@ export function toolEndResultToUserFrame(arm) {
         isError: arm.isError === true,
     }, undefined, parent === null ? 'leader' : 'subagent');
     const envelope = toolResultEnvelopeParts(outcome);
+    const content = Array.isArray(outcome.body.content) ? outcome.body.content : arm.truncated === true ? `${text}\n…(truncated)` : text;
     return {
         type: 'user',
         message: {
@@ -37,13 +24,14 @@ export function toolEndResultToUserFrame(arm) {
                 {
                     type: 'tool_result',
                     tool_use_id: arm.toolCallId,
-                    content: arm.truncated === true ? `${text}\n…(truncated)` : text,
-                    is_error: arm.isError === true || bashExitCodeFailed(arm.toolName, text, arm.structured),
+                    content,
+                    is_error: outcome.body.isError,
                 },
             ],
         },
         parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
+        ...(readFrameTrueMark(arm, 'notExecuted') ? { _sema_not_executed: true } : {}),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: arm.uuid,

package/dist/promptBlockedCopy.d.ts

@@ -0,0 +1,5 @@
+import type { RunTerminalRead } from './runTerminal.js';
+export declare const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = "UserPromptSubmit operation blocked by hook";
+export declare function runBlockedText(blocked: Extract<RunTerminalRead, {
+    kind: 'blocked';
+}>): string;

package/dist/promptBlockedCopy.js

@@ -0,0 +1,35 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { stripSystemReminderTagTokens, unwrapSystemReminder } from './systemReminderTag.js';
+export const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = 'UserPromptSubmit operation blocked by hook';
+const RUN_BLOCKED_REASONED = 'Run blocked';
+const RUN_BLOCKED_NO_REASON = 'Run blocked (the agent reported it cannot proceed)';
+const HOOK_WORDS_SHOWN_MAX = 1000;
+const CAUSE_CLAUSE = Object.freeze({
+    crashed: 'the hook failed before it answered; the prompt was not submitted',
+    timeout: 'the hook did not answer in time; the prompt was not submitted',
+    cancelled: 'the run was cancelled while the hook was checking the prompt; the prompt was not submitted',
+});
+function shownHookWords(words) {
+    if (words === undefined)
+        return undefined;
+    const shown = stripSystemReminderTagTokens(displayUntrusted(stripSystemReminderTagTokens(words), { max: HOOK_WORDS_SHOWN_MAX })).trim();
+    return shown === '' ? undefined : shown;
+}
+export function runBlockedText(blocked) {
+    const detail = blocked.detail;
+    if (detail !== undefined && detail.kind === 'prompt_blocked_by_hook') {
+        const clause = detail.cause !== 'unrecognized' && Object.hasOwn(CAUSE_CLAUSE, detail.cause) ? CAUSE_CLAUSE[detail.cause] : undefined;
+        const words = shownHookWords(detail.hookReason);
+        if (clause !== undefined)
+            return `${PROMPT_BLOCKED_BY_HOOK_ROW_LEAD}: ${clause}${words !== undefined ? `\n${words}` : ''}`;
+        return words !== undefined ? `${PROMPT_BLOCKED_BY_HOOK_ROW_LEAD}:\n${words}` : PROMPT_BLOCKED_BY_HOOK_ROW_LEAD;
+    }
+    const reason = blocked.reason;
+    if (reason === undefined)
+        return RUN_BLOCKED_NO_REASON;
+    const unwrapped = unwrapSystemReminder(reason);
+    if (unwrapped === reason)
+        return `${RUN_BLOCKED_REASONED}: ${reason}`;
+    const body = stripSystemReminderTagTokens(unwrapped).trim();
+    return body === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
+}

package/dist/promptDelivery.js

@@ -132,14 +132,6 @@ export function frameProvesDelivery(event) {
         const type = event.type;
         if (typeof type !== 'string' || type.length === 0 || PRE_RUN_FRAME_TYPES.has(type))
             return false;
-        if (type === 'done') {
-            const result = event.result;
-            if (typeof result === 'object' && result !== null && !Array.isArray(result) && result.status === undefined) {
-                const r = result;
-                if (activeRunBusySignal({ type: 'failed', errorCode: r.errorCode, activeTaskId: r.activeTaskId }) !== null)
-                    return false;
-            }
-        }
         return activeRunBusySignal(event) === null;
     }
     catch {

package/dist/protocolSegment.d.ts

@@ -1,12 +1,15 @@
-export type ProtocolSegment = {
-    readonly kind: 'ok';
+export type RuleToolNameReading = {
+    readonly kind: 'current';
 } | {
-    readonly kind: 'empty';
+    readonly kind: 'retired';
+    readonly currentName?: string;
 } | {
-    readonly kind: 'unminted';
-    readonly minted?: string;
+    readonly kind: 'unprefixed_namespace';
+} | {
+    readonly kind: 'unmintable_segment';
 } | {
     readonly kind: 'unknown';
 };
-export declare function protocolSegmentOf(name: string): ProtocolSegment;
+export declare function ruleToolNameVerdictOf(name: string): RuleToolNameReading;
+export declare function mintedPrefixOf(name: string): string | undefined;
 export declare function clientOwnedServerPrefix(server: string): string | undefined;

package/dist/protocolSegment.js

@@ -1,33 +1,43 @@
-import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
-import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
-export function protocolSegmentOf(name) {
-    if (CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix) && name.slice(prefix.length).split('__')[0] === ''))
-        return { kind: 'empty' };
-    const ns = protocolOf(name);
-    if (ns === undefined)
-        return hasCoreValuePort('protocolOf') ? { kind: 'ok' } : { kind: 'unknown' };
-    let parsed;
+import { mcpNamespace, mintNamespacePrefix, protocolOf, ruleToolNameJudgement } from './coreValuePorts.js';
+export function ruleToolNameVerdictOf(name) {
+    let kind;
+    let currentName;
     try {
-        parsed = ns.parse(name);
+        const v = ruleToolNameJudgement(name, new Set());
+        if (v === null || typeof v !== 'object')
+            return { kind: 'unknown' };
+        kind = v.kind;
+        if (kind === 'retired')
+            currentName = v.currentName;
     }
     catch {
         return { kind: 'unknown' };
     }
-    const peer = parsed?.peer;
-    if (typeof peer !== 'string')
-        return { kind: 'ok' };
-    if (peer.includes('*'))
-        return { kind: 'unminted' };
-    let minted;
+    switch (kind) {
+        case 'current':
+        case 'unprefixed_namespace':
+        case 'unmintable_segment':
+            return { kind };
+        case 'retired':
+            return typeof currentName === 'string' && currentName !== '' ? { kind, currentName } : { kind };
+        default:
+            return { kind: 'unknown' };
+    }
+}
+export function mintedPrefixOf(name) {
     try {
-        minted = mintNamespacePrefix(ns, peer);
+        const ns = protocolOf(name);
+        if (ns === undefined)
+            return undefined;
+        const peer = ns.parse(name)?.peer;
+        if (typeof peer !== 'string' || peer.includes('*'))
+            return undefined;
+        const minted = mintNamespacePrefix(ns, peer);
+        return typeof minted === 'string' ? minted : undefined;
     }
     catch {
-        return { kind: 'unknown' };
+        return undefined;
     }
-    if (typeof minted !== 'string')
-        return { kind: 'unknown' };
-    return minted === `${ns.prefix}${peer}__` ? { kind: 'ok' } : { kind: 'unminted', minted };
 }
 export function clientOwnedServerPrefix(server) {
     try {

package/dist/providerRejection.d.ts

@@ -1,8 +1,12 @@
 import { type RunTerminalFailureDetail } from './runTerminal.js';
 import { type ToolHistoryErrorCarrier } from './toolHistoryMismatch.js';
+export declare const PROVIDER_REJECTION_KINDS: readonly ["schema_invalid", "auth", "rate_limited", "resend_eligible", "unknown"];
+export type ProviderRejectionKind = (typeof PROVIDER_REJECTION_KINDS)[number];
 export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;
+    kind: ProviderRejectionKind;
 }
 export declare function readProviderRejectionResendKey(v: object | null | undefined): ProviderRejectionResend | undefined;
 export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;
+export declare function providerRejectionKind(detail: RunTerminalFailureDetail | null | undefined): ProviderRejectionKind;

package/dist/providerRejection.js

@@ -18,6 +18,28 @@ function providerStatusTier(status) {
     return UNTIERED;
 }
 const EDITABLE_TIER = 'invalid_request';
+export const PROVIDER_REJECTION_KINDS = Object.freeze(['schema_invalid', 'auth', 'rate_limited', 'resend_eligible', 'unknown']);
+const SCHEMA_INVALID_CODES = new Set([
+    'invalid_type',
+    'missing_required_parameter',
+    'unknown_parameter',
+    'unsupported_parameter',
+    'invalid_function_parameters',
+    'invalid_json_schema',
+]);
+function schemaTierStatus(status) {
+    return status === 400 || status === 422;
+}
+function kindOfStatus(status, code) {
+    const tier = providerStatusTier(status);
+    if (tier === 'authentication_failed')
+        return 'auth';
+    if (tier === 'rate_limit')
+        return 'rate_limited';
+    if (tier === EDITABLE_TIER)
+        return code !== undefined && schemaTierStatus(status) && SCHEMA_INVALID_CODES.has(code) ? 'schema_invalid' : 'resend_eligible';
+    return 'unknown';
+}
 const NOT_BY_EDITING_TAIL = new Map([
     ['authentication_failed', ': check the provider credentials or access for this account.'],
     ['model_not_found', ': the model is not available from this provider — choose another model.'],
@@ -30,26 +52,40 @@ function toolHistoryMismatchCarrier(carrier) {
 }
 const PROVIDER_REJECTED = 'provider_rejected';
 const RESEND_TEXT_STATUS = /\(HTTP (\d{3})\)/;
+function ownDataOf(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+}
 export function readProviderRejectionResendKey(v) {
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
             return undefined;
-        const got = v;
-        const resend = got.resend;
-        const text = got.text;
+        const resend = ownDataOf(v, 'resend');
+        const text = ownDataOf(v, 'text');
+        const kind = ownDataOf(v, 'kind');
         if (typeof text !== 'string' || (resend !== 'edit_and_resend' && resend !== 'not_by_editing'))
             return undefined;
         const hit = RESEND_TEXT_STATUS.exec(text);
         if (hit === null || hit[1] === undefined)
             return undefined;
-        const again = providerRejectionResend({ kind: PROVIDER_REJECTED, status: Number(hit[1]) });
-        return again !== undefined && again.resend === resend && again.text === text ? { resend: again.resend, text: again.text } : undefined;
+        const rej = readRejection({ kind: PROVIDER_REJECTED, status: Number(hit[1]) });
+        if (rej === undefined)
+            return undefined;
+        let wanted;
+        if (kind === undefined)
+            wanted = kindOfStatus(rej.status, undefined);
+        else if (typeof kind === 'string' && PROVIDER_REJECTION_KINDS.includes(kind))
+            wanted = kind;
+        else
+            return undefined;
+        const again = verdictOf(rej.status, wanted);
+        return again !== undefined && again.resend === resend && again.text === text ? { resend: again.resend, text: again.text, kind: again.kind } : undefined;
     }
     catch {
         return undefined;
     }
 }
-export function providerRejectionResend(detail, carrier) {
+function readRejection(detail) {
     let read;
     try {
         const r = readRunTerminal({ terminal: { kind: 'failed', detail } });
@@ -63,16 +99,41 @@ export function providerRejectionResend(detail, carrier) {
     const status = Object.hasOwn(read, 'status') ? read.status : undefined;
     if (status === undefined)
         return undefined;
-    if (toolHistoryMismatchCarrier(carrier))
+    return { status, code: Object.hasOwn(read, 'code') ? read.code : undefined };
+}
+function schemaInvalidText(status) {
+    return `The model provider rejected the structure of this request (HTTP ${status}) — rewording the message will not fix this. Check that the configured model and endpoint accept this kind of request, or report the problem to whoever runs the engine.`;
+}
+function verdictOf(status, kind) {
+    if (kind === 'schema_invalid') {
+        if (providerStatusTier(status) !== EDITABLE_TIER || !schemaTierStatus(status))
+            return undefined;
+        return { resend: 'not_by_editing', text: schemaInvalidText(status), kind };
+    }
+    if (kind !== kindOfStatus(status, undefined))
         return undefined;
-    const tier = providerStatusTier(status);
-    return tier === EDITABLE_TIER
-        ? {
+    if (kind === 'resend_eligible') {
+        return {
             resend: 'edit_and_resend',
             text: `The model provider rejected this request as sent (HTTP ${status}). Change it — for example shorten it or remove an attachment — and send it again.`,
-        }
-        : {
-            resend: 'not_by_editing',
-            text: `The model provider refused this request (HTTP ${status})${NOT_BY_EDITING_TAIL.get(tier) ?? NOT_BY_EDITING_TAIL.get(UNTIERED) ?? ''}`,
+            kind,
         };
+    }
+    return {
+        resend: 'not_by_editing',
+        text: `The model provider refused this request (HTTP ${status})${NOT_BY_EDITING_TAIL.get(providerStatusTier(status)) ?? NOT_BY_EDITING_TAIL.get(UNTIERED) ?? ''}`,
+        kind,
+    };
+}
+export function providerRejectionResend(detail, carrier) {
+    const r = readRejection(detail);
+    if (r === undefined)
+        return undefined;
+    if (toolHistoryMismatchCarrier(carrier))
+        return undefined;
+    return verdictOf(r.status, kindOfStatus(r.status, r.code));
+}
+export function providerRejectionKind(detail) {
+    const r = readRejection(detail);
+    return r === undefined ? 'unknown' : kindOfStatus(r.status, r.code);
 }

package/dist/replayBody.d.ts

@@ -0,0 +1,12 @@
+export interface ReplayRowView {
+    readonly status?: string;
+    readonly errorCode?: string;
+    readonly error?: string;
+    readonly sessionId?: string;
+}
+export interface DoneResultView {
+    readonly replay: boolean;
+    readonly engine: unknown;
+    readonly row?: ReplayRowView;
+}
+export declare function doneResultView(result: unknown): DoneResultView;

package/dist/replayBody.js

@@ -0,0 +1,25 @@
+function guarded(o, k) {
+    try {
+        return o[k];
+    }
+    catch {
+        return undefined;
+    }
+}
+function guardedString(o, k) {
+    const v = guarded(o, k);
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function doneResultView(result) {
+    if (typeof result !== 'object' || result === null || Array.isArray(result))
+        return { replay: false, engine: result };
+    if (guarded(result, 'replay') !== true)
+        return { replay: false, engine: result };
+    const row = {};
+    for (const k of ['status', 'errorCode', 'error', 'sessionId']) {
+        const v = guardedString(result, k);
+        if (v !== undefined)
+            row[k] = v;
+    }
+    return { replay: true, engine: guarded(result, 'result'), row };
+}