@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.
- package/esm/src/guardrails/sanitize.d.ts +7 -1
- package/esm/src/guardrails/sanitize.js +11 -5
- package/esm/src/kernel/engine/runner/mod.js +8 -1
- package/esm/src/kernel/engine/runner/nested.js +7 -4
- package/esm/src/kernel/engine/runner/refused-media.d.ts +8 -1
- package/esm/src/kernel/engine/runner/refused-media.js +27 -0
- package/esm/src/kernel/engine/runner/state.d.ts +2 -0
- package/esm/src/kernel/registry/attachments.d.ts +25 -7
- package/esm/src/kernel/registry/attachments.js +45 -12
- package/esm/src/kernel/registry/ingress.js +2 -2
- package/esm/src/kernel/turn-events.d.ts +8 -3
- package/package.json +1 -1
|
@@ -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
|
-
/**
|
|
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
|
-
/**
|
|
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
|
-
...(
|
|
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
|
|
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:
|
|
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
|
|
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
|
-
/**
|
|
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
|
-
/**
|
|
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
|
-
|
|
57
|
-
|
|
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
|
-
/**
|
|
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
|
-
/**
|
|
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
|
-
|
|
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
|
|
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 `
|
|
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
|
|
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
|
|
595
|
-
*
|
|
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
|
-
/**
|
|
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.
|
|
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",
|