@theoremjs/agents 0.3.5-next.958.gc25a02b → 0.3.5-next.959.g351c307

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,3 +1,4 @@
1
+ import { type LeftOutFile } from '../kernel/registry/attachments.js';
1
2
  import type { NormalizedTurnRequest, Profile, TurnContext, TurnEvent, TurnHistoryMessage, TurnRequest } from '../kernel/types.js';
2
3
  import { type Boundary } from './boundaries.js';
3
4
  import { type BoundaryReader } from './detect-at.js';
@@ -27,6 +28,8 @@ interface SanitizedTurnRequest {
27
28
  events: TurnEvent[];
28
29
  /** Set when a match blocks: the request does not reach the model, and the turn ends on this. */
29
30
  refusal?: TheoremError;
31
+ /** The files the profile does not take, left out of `request`; the turn goes on without them. */
32
+ leftOut: LeftOutFile[];
30
33
  }
31
34
  /**
32
35
  * `req.system` is host-assembled per turn — it interpolates retrieval and user
@@ -34,7 +37,10 @@ interface SanitizedTurnRequest {
34
37
  * path and stays verbatim.
35
38
  */
36
39
  declare function sanitizeTurnRequestWithEvents(req: TurnRequest, profile: Profile): SanitizedTurnRequest;
37
- /** The turn request with its input cleaned under the profile's guardrails. Throws when a match blocks it. */
40
+ /**
41
+ * The turn request with its input cleaned under the profile's guardrails. Throws when a match
42
+ * blocks it, and when the profile does not take one of its files: nothing here goes on without it.
43
+ */
38
44
  declare function sanitizeTurnRequest(req: TurnRequest, profile: Profile): NormalizedTurnRequest;
39
45
  export type { SanitizedTurnRequest };
40
46
  export { contextText, requestRefused, sanitizeContext, sanitizeHistory, sanitizeProjectId, sanitizeTurnRequest, sanitizeTurnRequestWithEvents, };
@@ -1,4 +1,4 @@
1
- import { sanitizeTurnBlobs } from '../kernel/registry/attachments.js';
1
+ import { attachmentsRefused, sanitizeTurnBlobs, } from '../kernel/registry/attachments.js';
2
2
  import { CONTEXT_SENDERS } from '../kernel/schema.js';
3
3
  import { mapSystemPrompt } from '../kernel/system-parts.js';
4
4
  import { recordOf } from './boundaries.js';
@@ -124,9 +124,9 @@ function sanitizeTurnRequestWithEvents(req, profile) {
124
124
  const told = sanitizeContext(input.context, () => boundaryReader('context', detect));
125
125
  const repair = sanitizeRepair(input.repair, at.repair);
126
126
  const history = input.history ? sanitizeHistory(input.history, at.history) : undefined;
127
- const { attachments, voice } = input.attachments?.length || input.voice?.length
127
+ const { attachments, voice, leftOut } = input.attachments?.length || input.voice?.length
128
128
  ? sanitizeTurnBlobs(profile, input.attachments, input.voice, at)
129
- : input;
129
+ : { ...input, leftOut: [] };
130
130
  const events = [];
131
131
  let refusal;
132
132
  for (const boundary of REQUEST_BOUNDARIES) {
@@ -159,13 +159,19 @@ function sanitizeTurnRequestWithEvents(req, profile) {
159
159
  },
160
160
  events,
161
161
  ...(refusal ? { refusal } : {}),
162
+ leftOut,
162
163
  };
163
164
  }
164
- /** The turn request with its input cleaned under the profile's guardrails. Throws when a match blocks it. */
165
+ /**
166
+ * The turn request with its input cleaned under the profile's guardrails. Throws when a match
167
+ * blocks it, and when the profile does not take one of its files: nothing here goes on without it.
168
+ */
165
169
  function sanitizeTurnRequest(req, profile) {
166
- const { request, refusal } = sanitizeTurnRequestWithEvents(req, profile);
170
+ const { request, refusal, leftOut } = sanitizeTurnRequestWithEvents(req, profile);
167
171
  if (refusal)
168
172
  throw refusal;
173
+ if (leftOut.length > 0)
174
+ throw attachmentsRefused(leftOut.flatMap((file) => file.issues));
169
175
  return request;
170
176
  }
171
177
  export { contextText, requestRefused, sanitizeContext, sanitizeHistory, sanitizeProjectId, sanitizeTurnRequest, sanitizeTurnRequestWithEvents, };
@@ -24,6 +24,7 @@ import { endThrownSpan, endTurnSpan, guardrailAttributes, guardrailCheckAttribut
24
24
  import { sumEventTokens, sumTurnTokens } from '../usage.js';
25
25
  import { runAttemptsWithValidation } from './gates.js';
26
26
  import { createAgentCaller, NESTED_THROWS, turnError } from './nested.js';
27
+ import { leftOutNotes, leftOutReport, turnMediaRefused } from './refused-media.js';
27
28
  import { applyTurnStage, landLateResultsAt, unreadLateResultsAt, } from './stages.js';
28
29
  import { cutConversation, openTurnState, } from './state.js';
29
30
  import { shouldSkipStreamEvent } from './stream.js';
@@ -265,6 +266,8 @@ async function* emitTurn(args) {
265
266
  ...(args.steers ? { steers: args.steers } : {}),
266
267
  });
267
268
  args.outState.state = state;
269
+ if (args.leftOut)
270
+ state.leftOut = args.leftOut;
268
271
  const opening = { stage: 'pre_turn', step: 0 };
269
272
  const late = yield* unreadLateResultsAt(state, profile, {
270
273
  ...opening,
@@ -305,10 +308,11 @@ async function* emitTurn(args) {
305
308
  }
306
309
  yield* runAttemptsWithValidation(safe, profile, generation, system, provider, state);
307
310
  const tokens = sumTurnTokens(state.allEmittedEvents);
311
+ const mediaRefused = turnMediaRefused(state.leftOut, state.mediaRefused);
308
312
  const done = turnDoneOf({
309
313
  stop: state.lastStop ?? { kind: 'completed' },
310
314
  steps: state.stepCount,
311
- ...(state.mediaRefused ? { mediaRefused: state.mediaRefused } : {}),
315
+ ...(mediaRefused ? { mediaRefused } : {}),
312
316
  ...(state.providerState &&
313
317
  !cutConversation(state) &&
314
318
  !('providerContinuation' in profile && profile.providerContinuation?.history === 'stateless') &&
@@ -336,6 +340,7 @@ async function* streamTurnEvents(ctx, profile, gen, provider, compactionSpec) {
336
340
  background: ctx.background,
337
341
  steers: ctx.steers,
338
342
  outState: ctx,
343
+ leftOut: ctx.leftOut,
339
344
  })) {
340
345
  const crashes = [];
341
346
  const attached = await maybeAttachAfter(event, ctx, gen, compactionSpec, crashes);
@@ -524,6 +529,8 @@ async function* runTurnBody(ctx, provider) {
524
529
  if (sanitized.refusal)
525
530
  throw sanitized.refusal;
526
531
  const { profile, generation: gen } = resolveTurnInRegistry(ctx.registry, ctx.safe);
532
+ gen.input.push(...leftOutNotes(sanitized.leftOut, profile.labels));
533
+ ctx.leftOut = leftOutReport(sanitized.leftOut);
527
534
  const t1Policy = await applyT1Policy(ctx.registry.tools, gen.tools, profile, ctx.safe);
528
535
  if (t1Policy) {
529
536
  yield deliver(ctx, hookFailed('tools.t1Policy', t1Policy.crashed, { span: ctx.root }));
@@ -2,6 +2,7 @@ import { errorCopyText, isAbortError, TheoremError, throwIfAborted, toErrorEvent
2
2
  import { labelText } from '../../../guardrails/labels.js';
3
3
  import { hookCrashFailure, hookFailed } from '../../hook-failure.js';
4
4
  import { nestedTurnModel, resolveRegisteredTurnModel } from '../../provider-dispatch.js';
5
+ import { assertTurnAttachments } from '../../registry/attachments.js';
5
6
  import { profileAllowsInject } from '../../stop.js';
6
7
  import { agentProfileProblem, agentToolOutputOf, splitHostInput, } from '../../tools/agent.js';
7
8
  import { findLast } from '../../util/find-last.js';
@@ -73,14 +74,15 @@ function createAgentCaller(args) {
73
74
  throw new TheoremError('internal', `Agent tool "${tool.name}" ran without a span`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
74
75
  }
75
76
  const { speech, ...sent } = modelInput;
76
- const events = yield* nestedEvents(args.runNested({
77
+ const turnInput = fields.input ?? sent;
78
+ const events = yield* nestedEvents(() => assertTurnAttachments(profile, turnInput.attachments, turnInput.voice), args.runNested({
77
79
  req: {
78
80
  ...(speech ? { speech } : {}),
79
81
  ...fields,
80
82
  profile: tool.profile,
81
83
  execution: req.execution,
82
84
  pageExecution: req.pageExecution,
83
- input: fields.input ?? sent,
85
+ input: turnInput,
84
86
  ...(signal ? { signal } : {}),
85
87
  ...(req.onAgentCall ? { onAgentCall: req.onAgentCall } : {}),
86
88
  },
@@ -95,16 +97,17 @@ function createAgentCaller(args) {
95
97
  };
96
98
  }
97
99
  /** Relays an agent's turn and keeps its events; a turn refused before it starts ends in its error event. */
98
- async function* nestedEvents(turn) {
100
+ async function* nestedEvents(check, turn) {
99
101
  const events = [];
100
102
  try {
103
+ check();
101
104
  for await (const event of turn) {
102
105
  events.push(event);
103
106
  yield event;
104
107
  }
105
108
  }
106
109
  catch (err) {
107
- // why: A turn refused before it starts (a file the agent does not take) throws; the caller's model reads it like any other failed call.
110
+ // why: A file the agent does not take refuses its turn before it starts, where a person's turn goes on without it: the caller's model reads why and can correct the call.
108
111
  if (!(err instanceof TheoremError) || NESTED_THROWS.has(err.kind) || isAbortError(err)) {
109
112
  throw err;
110
113
  }
@@ -1,5 +1,6 @@
1
+ import type { LeftOutFile } from '../../registry/attachments.js';
1
2
  import type { MediaRefused, RefusedMedia } from '../../turn-events.js';
2
- import type { Profile, TurnHistoryMessage } from '../../types.js';
3
+ import type { InteractionPart, Profile, TurnHistoryMessage } from '../../types.js';
3
4
  import type { StepExecutionState } from './state.js';
4
5
  /** The files a retry took out, and how to put them back if the retry fails too. */
5
6
  export interface RefusedMediaTry {
@@ -24,3 +25,9 @@ export declare function dropMedia(state: StepExecutionState, said: string, label
24
25
  export declare function restoreMedia(state: StepExecutionState, tried: RefusedMediaTry): void;
25
26
  /** What the host reads on `done`. */
26
27
  export declare function refusedReport(tried: RefusedMediaTry): MediaRefused;
28
+ /** The note the model reads in place of each file the profile does not take. */
29
+ export declare function leftOutNotes(leftOut: readonly LeftOutFile[], labels: Profile['labels']): InteractionPart[];
30
+ /** The files the profile does not take, as `done.mediaRefused` reports them; `said` names each check that failed. */
31
+ export declare function leftOutReport(leftOut: readonly LeftOutFile[]): MediaRefused | undefined;
32
+ /** The turn's report: the files left out at ingress, then the ones the provider refused. */
33
+ export declare function turnMediaRefused(leftOut: MediaRefused | undefined, refused: MediaRefused | undefined): MediaRefused | undefined;
@@ -92,3 +92,30 @@ export function restoreMedia(state, tried) {
92
92
  export function refusedReport(tried) {
93
93
  return { dropped: tried.dropped, said: tried.said };
94
94
  }
95
+ /** The note the model reads in place of each file the profile does not take. */
96
+ export function leftOutNotes(leftOut, labels) {
97
+ return leftOut.map((file) => ({
98
+ type: 'text',
99
+ text: labelText(noteKey(file.mimeType.toLowerCase(), false), {}, labels),
100
+ }));
101
+ }
102
+ /** The files the profile does not take, as `done.mediaRefused` reports them; `said` names each check that failed. */
103
+ export function leftOutReport(leftOut) {
104
+ if (leftOut.length === 0)
105
+ return undefined;
106
+ return {
107
+ dropped: leftOut.map((file) => ({ mimeType: file.mimeType, from: 'input' })),
108
+ said: leftOut
109
+ .map((file) => `${file.mimeType}: ${file.issues.map((issue) => issue.code).join(', ')}`)
110
+ .join('\n'),
111
+ };
112
+ }
113
+ /** The turn's report: the files left out at ingress, then the ones the provider refused. */
114
+ export function turnMediaRefused(leftOut, refused) {
115
+ if (!leftOut || !refused)
116
+ return leftOut ?? refused;
117
+ return {
118
+ dropped: [...leftOut.dropped, ...refused.dropped],
119
+ said: `${leftOut.said}\n${refused.said}`,
120
+ };
121
+ }
@@ -45,6 +45,8 @@ interface StepExecutionState {
45
45
  /** The files this turn's refused calls went without: each type the provider named once, or every file once. */
46
46
  mediaTry?: RefusedMediaTry;
47
47
  mediaRefused?: MediaRefused;
48
+ /** The files the profile does not take, left out before the turn began. */
49
+ leftOut?: MediaRefused;
48
50
  allEmittedEvents: TurnEvent[];
49
51
  attemptEvents: TurnEvent[];
50
52
  /**
@@ -36,7 +36,10 @@ export interface AttachmentRules {
36
36
  voice?: string[];
37
37
  limits?: MediaLimits;
38
38
  }
39
- /** The one attachment check: the kernel throws on it at ingress and the headless interface runs it before a send. */
39
+ /**
40
+ * The one attachment check. The headless interface runs it before a send; at ingress the kernel
41
+ * runs it on each file, leaves out the files it names, and throws only on what names no file.
42
+ */
40
43
  declare function attachmentIssues(rules: AttachmentRules, files: AttachmentFacts[], clips: AttachmentFacts[]): AttachmentValidationIssue[];
41
44
  /** The user-facing wording key and params for an attachment issue. */
42
45
  declare function attachmentIssueCopy(issue: AttachmentValidationIssue): ErrorCopy;
@@ -46,14 +49,29 @@ declare function attachmentIssueText(issue: AttachmentValidationIssue, labels?:
46
49
  declare function attachmentsRefused(issues: readonly AttachmentValidationIssue[]): TheoremError;
47
50
  /** The decoded size of inline base64 data; throws when it is not base64. */
48
51
  declare function base64Bytes(data: string): number;
49
- /** Provider references are checked for MIME and count; byte limits apply to inline blobs only. */
52
+ /** Throws on every issue the check finds: a host's own check before a send. */
50
53
  declare function assertTurnAttachments(profile: Profile, attachments: Array<TurnBlob | TurnMediaRef> | undefined, voice: TurnBlob[] | undefined): void;
54
+ /** A file the turn goes without, and what the check found wrong with it. */
55
+ interface LeftOutFile {
56
+ mimeType: string;
57
+ channel: 'attachment' | 'voice';
58
+ issues: AttachmentValidationIssue[];
59
+ }
60
+ interface TurnFiles {
61
+ attachments?: Array<TurnBlob | TurnMediaRef>;
62
+ voice?: TurnBlob[];
63
+ leftOut: LeftOutFile[];
64
+ }
65
+ /**
66
+ * invariant: a file the profile does not take is left out and the turn goes on; what names no file
67
+ * (too many files, too many bytes in all) refuses the turn, since no one file is at fault.
68
+ * Provider references are checked for MIME and count; byte limits apply to inline blobs only.
69
+ */
70
+ declare function splitTurnAttachments(profile: Profile, attachments: Array<TurnBlob | TurnMediaRef> | undefined, voice: TurnBlob[] | undefined): TurnFiles;
51
71
  /** Provider file references pass through unsanitized: the kernel has no bytes to scan. */
52
72
  declare function sanitizeTurnBlobs(profile: Profile, attachments: Array<TurnBlob | TurnMediaRef> | undefined, voice: TurnBlob[] | undefined, at: {
53
73
  attachment: BoundaryReader;
54
74
  voice: BoundaryReader;
55
- }): {
56
- attachments?: Array<TurnBlob | TurnMediaRef>;
57
- voice?: TurnBlob[];
58
- };
59
- export { assertTurnAttachments, attachmentIssueCopy, attachmentIssues, attachmentIssueText, attachmentsRefused, base64Bytes, isTextFile, isTextFileData, isTurnMediaRef, maxBytesForMime, modelTextFile, requireMediaLimits, resolveMediaLimits, rewriteTextFile, sanitizeCsvText, sanitizeTurnBlobs, textFileText, };
75
+ }): TurnFiles;
76
+ export type { LeftOutFile, TurnFiles };
77
+ export { assertTurnAttachments, attachmentIssueCopy, attachmentIssues, attachmentIssueText, attachmentsRefused, base64Bytes, isTextFile, isTextFileData, isTurnMediaRef, maxBytesForMime, modelTextFile, requireMediaLimits, resolveMediaLimits, rewriteTextFile, sanitizeCsvText, sanitizeTurnBlobs, splitTurnAttachments, textFileText, };
@@ -2,7 +2,7 @@ import { TheoremError } from '../../guardrails/error.js';
2
2
  import { labelText, } from '../../guardrails/labels.js';
3
3
  import { base64ToBytes, bytesToBase64 } from '../util/base64.js';
4
4
  import { mimeEssence } from '../util/mime.js';
5
- import { mimeAllowed, profileAccept } from './catalog.js';
5
+ import { mediaKindForMime, mimeAllowed, profileAccept } from './catalog.js';
6
6
  const B64_PAD = 2;
7
7
  const B64_WORD = 4;
8
8
  const B64_TRIPLET = 3;
@@ -254,7 +254,7 @@ function named(issue, name) {
254
254
  }
255
255
  function mimeIssues(accept, files, channel) {
256
256
  return files
257
- .filter((file) => !mimeAllowed(accept, file.mimeType))
257
+ .filter((file) => !mediaKindForMime(file.mimeType) || !mimeAllowed(accept, file.mimeType))
258
258
  .map((file) => named({ code: 'mime_not_allowed', params: { mimeType: file.mimeType, channel } }, file.name));
259
259
  }
260
260
  function limitIssues(files, limits) {
@@ -277,7 +277,10 @@ function limitIssues(files, limits) {
277
277
  }
278
278
  return issues;
279
279
  }
280
- /** The one attachment check: the kernel throws on it at ingress and the headless interface runs it before a send. */
280
+ /**
281
+ * The one attachment check. The headless interface runs it before a send; at ingress the kernel
282
+ * runs it on each file, leaves out the files it names, and throws only on what names no file.
283
+ */
281
284
  function attachmentIssues(rules, files, clips) {
282
285
  const issues = [];
283
286
  if (files.length > 0 && !rules.attachments) {
@@ -345,19 +348,46 @@ function factsOf(item) {
345
348
  facts.sizeBytes = base64Bytes(item.data);
346
349
  return facts;
347
350
  }
348
- /** Provider references are checked for MIME and count; byte limits apply to inline blobs only. */
351
+ /** Throws on every issue the check finds: a host's own check before a send. */
349
352
  function assertTurnAttachments(profile, attachments, voice) {
350
353
  if (!hasTurnBlobs(attachments, voice))
351
354
  return;
352
- const limits = requireMediaLimits(profile);
353
355
  const issues = attachmentIssues({
354
356
  attachments: profileAccept(profile, 'attachments'),
355
357
  voice: profileAccept(profile, 'voice'),
356
- limits,
358
+ limits: requireMediaLimits(profile),
357
359
  }, (attachments ?? []).map(factsOf), (voice ?? []).map(factsOf));
358
360
  if (issues.length > 0)
359
361
  throw attachmentsRefused(issues);
360
362
  }
363
+ /**
364
+ * invariant: a file the profile does not take is left out and the turn goes on; what names no file
365
+ * (too many files, too many bytes in all) refuses the turn, since no one file is at fault.
366
+ * Provider references are checked for MIME and count; byte limits apply to inline blobs only.
367
+ */
368
+ function splitTurnAttachments(profile, attachments, voice) {
369
+ if (!hasTurnBlobs(attachments, voice))
370
+ return { attachments, voice, leftOut: [] };
371
+ const rules = {
372
+ attachments: profileAccept(profile, 'attachments'),
373
+ voice: profileAccept(profile, 'voice'),
374
+ limits: requireMediaLimits(profile),
375
+ };
376
+ const leftOut = [];
377
+ const keep = (items, channel) => items?.filter((item) => {
378
+ const one = [factsOf(item)];
379
+ const issues = channel === 'voice' ? attachmentIssues(rules, [], one) : attachmentIssues(rules, one, []);
380
+ if (issues.length === 0)
381
+ return true;
382
+ leftOut.push({ mimeType: item.mimeType, channel, issues });
383
+ return false;
384
+ });
385
+ const kept = { attachments: keep(attachments, 'attachment'), voice: keep(voice, 'voice') };
386
+ const issues = attachmentIssues(rules, (kept.attachments ?? []).map(factsOf), (kept.voice ?? []).map(factsOf));
387
+ if (issues.length > 0)
388
+ throw attachmentsRefused(issues);
389
+ return { ...kept, leftOut };
390
+ }
361
391
  function sanitizeAttachment(blob, reader) {
362
392
  if (isTurnMediaRef(blob)) {
363
393
  return blob;
@@ -380,12 +410,15 @@ function hasTurnBlobs(attachments, voice) {
380
410
  }
381
411
  /** Provider file references pass through unsanitized: the kernel has no bytes to scan. */
382
412
  function sanitizeTurnBlobs(profile, attachments, voice, at) {
383
- assertTurnAttachments(profile, attachments, voice);
413
+ const kept = splitTurnAttachments(profile, attachments, voice);
384
414
  return {
385
- attachments: attachments?.length
386
- ? attachments.map((blob) => sanitizeAttachment(blob, at.attachment))
387
- : attachments,
388
- voice: voice?.length ? voice.map((blob) => sanitizeAttachment(blob, at.voice)) : voice,
415
+ attachments: kept.attachments?.length
416
+ ? kept.attachments.map((blob) => sanitizeAttachment(blob, at.attachment))
417
+ : kept.attachments,
418
+ voice: kept.voice?.length
419
+ ? kept.voice.map((blob) => sanitizeAttachment(blob, at.voice))
420
+ : kept.voice,
421
+ leftOut: kept.leftOut,
389
422
  };
390
423
  }
391
- export { assertTurnAttachments, attachmentIssueCopy, attachmentIssues, attachmentIssueText, attachmentsRefused, base64Bytes, isTextFile, isTextFileData, isTurnMediaRef, maxBytesForMime, modelTextFile, requireMediaLimits, resolveMediaLimits, rewriteTextFile, sanitizeCsvText, sanitizeTurnBlobs, textFileText, };
424
+ export { assertTurnAttachments, attachmentIssueCopy, attachmentIssues, attachmentIssueText, attachmentsRefused, base64Bytes, isTextFile, isTextFileData, isTurnMediaRef, maxBytesForMime, modelTextFile, requireMediaLimits, resolveMediaLimits, rewriteTextFile, sanitizeCsvText, sanitizeTurnBlobs, splitTurnAttachments, textFileText, };
@@ -85,7 +85,7 @@ function assertMediaMime(mime) {
85
85
  }
86
86
  return kind;
87
87
  }
88
- /** Runs after `assertTurnAttachments`. A reference's uri passes untouched: the host owns the upload. */
88
+ /** Runs after `splitTurnAttachments`. A reference's uri passes untouched: the host owns the upload. */
89
89
  function mediaParts(blobs) {
90
90
  return blobs.map((blob) => {
91
91
  const kind = assertMediaMime(blob.mimeType);
@@ -142,7 +142,7 @@ function pinnedReferenceParts(profile) {
142
142
  ? mediaParts(profile.image.references)
143
143
  : [];
144
144
  }
145
- /** `sanitizeTurnRequest` has already checked the blobs against the profile's limits and accept lists. */
145
+ /** `sanitizeTurnRequest` has already left out the blobs the profile's limits and accept lists refuse. */
146
146
  function extractMediaParts(profile, req) {
147
147
  const files = req.input?.attachments ?? [];
148
148
  const clips = req.input?.voice ?? [];
@@ -591,12 +591,17 @@ export interface RefusedMedia {
591
591
  from: 'input' | 'history' | 'tool';
592
592
  }
593
593
  /**
594
- * The turn went on without files the provider refused. Set only when the same call, sent
595
- * without them, was accepted: that is the proof the files were at fault.
594
+ * The turn went on without files: first those the profile does not take (its `accept` lists and
595
+ * byte limits), left out before any call, then those the provider refused. A refused file is
596
+ * listed only when the same call, sent without it, was accepted: that is the proof it was at fault.
596
597
  */
597
598
  export interface MediaRefused {
598
599
  dropped: RefusedMedia[];
599
- /** The provider's own reason, for the builder only: `forClient` strips the whole report. */
600
+ /**
601
+ * Why, for the builder only: `forClient` strips the whole report. A line per file left out
602
+ * names its type and each check it failed (`image/gif: mime_not_allowed`); then the provider's
603
+ * own reason.
604
+ */
600
605
  said: string;
601
606
  }
602
607
  export interface DoneBase {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@theoremjs/agents",
3
- "version": "0.3.5-next.958.gc25a02b",
3
+ "version": "0.3.5-next.959.g351c307",
4
4
  "description": "A flat TypeScript agent kernel for typed profiles, deterministic turn execution, registered tools, provider adapters, guardrails, and host-injected traces.",
5
5
  "keywords": [
6
6
  "agent",