imprint-mcp 0.6.4 → 0.6.6
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/README.md +5 -0
- package/package.json +1 -1
- package/prompts/audit-agent.md +3 -3
- package/prompts/auth-compile-agent.md +46 -4
- package/prompts/compile-agent.md +36 -12
- package/prompts/live-verifier-agent.md +15 -5
- package/prompts/request-triage.md +51 -9
- package/prompts/tool-candidate-detection.md +7 -1
- package/prompts/tool-planning.md +1 -1
- package/src/cli.ts +71 -13
- package/src/imprint/audit.ts +23 -5
- package/src/imprint/auth-compile-agent.ts +11 -7
- package/src/imprint/auth-compile-tools.ts +127 -18
- package/src/imprint/auth-verifier.ts +2 -1
- package/src/imprint/backend-ladder.ts +20 -0
- package/src/imprint/build-plan.ts +21 -0
- package/src/imprint/claude-cli-compile.ts +7 -1
- package/src/imprint/codex-cli-compile.ts +6 -0
- package/src/imprint/compile-agent.ts +50 -9
- package/src/imprint/compile-tools.ts +308 -25
- package/src/imprint/compile-verification.ts +11 -2
- package/src/imprint/compile.ts +298 -69
- package/src/imprint/effects.ts +9 -0
- package/src/imprint/live-verifier.ts +455 -34
- package/src/imprint/login.ts +30 -12
- package/src/imprint/mcp-compile-server.ts +56 -5
- package/src/imprint/mcp-live-verifier-server.ts +43 -10
- package/src/imprint/probe-backends.ts +6 -0
- package/src/imprint/recording-request.ts +7 -2
- package/src/imprint/replay-capture.ts +48 -29
- package/src/imprint/request-capture.ts +14 -0
- package/src/imprint/runtime.ts +102 -22
- package/src/imprint/teach-state.ts +162 -21
- package/src/imprint/teach.ts +629 -226
- package/src/imprint/tool-candidates.ts +138 -0
- package/src/imprint/tool-plan.ts +2 -0
- package/src/imprint/triage-selection.ts +44 -0
- package/src/imprint/types.ts +39 -3
package/src/imprint/compile.ts
CHANGED
|
@@ -23,7 +23,7 @@ import type { SharedModuleManifestEntry } from './build-plan.ts';
|
|
|
23
23
|
import { type CompileAgentProgress, compileAgent } from './compile-agent.ts';
|
|
24
24
|
import { isSameRegistrableDomain, registrableDomain } from './etld.ts';
|
|
25
25
|
import { compactUrlForLlm } from './llm-url.ts';
|
|
26
|
-
import { type LLMOptions, extractJsonArray, resolveProvider } from './llm.ts';
|
|
26
|
+
import { type LLMOptions, extractJsonArray, extractJsonObject, resolveProvider } from './llm.ts';
|
|
27
27
|
import { loadJsonFile } from './load-json.ts';
|
|
28
28
|
import { createLog } from './log.ts';
|
|
29
29
|
import { imprintHomeDir, localSiteDir, localToolDir } from './paths.ts';
|
|
@@ -35,6 +35,7 @@ import type { ClassifiedValue } from './session-diff.ts';
|
|
|
35
35
|
import { isTelemetryRequest } from './telemetry.ts';
|
|
36
36
|
import type { SharedCompileContext, ToolCandidate } from './tool-candidates.ts';
|
|
37
37
|
import { setSpanAttributes, traced } from './tracing.ts';
|
|
38
|
+
import { applySharedTriageSelection } from './triage-selection.ts';
|
|
38
39
|
import {
|
|
39
40
|
type Playbook,
|
|
40
41
|
type Session,
|
|
@@ -81,7 +82,7 @@ interface GenerateOptions extends CompileOptions {
|
|
|
81
82
|
onProgress?: (p: CompileAgentProgress) => void;
|
|
82
83
|
/** Called when wall-clock deadline is reached; return ms to extend or null to time out. */
|
|
83
84
|
onDeadlineReached?: OnDeadlineReached;
|
|
84
|
-
/** Retain
|
|
85
|
+
/** Retain agent-generated tests after successful verification. */
|
|
85
86
|
keepTest?: boolean;
|
|
86
87
|
/** Directory where workflow.json/parser.ts/parser.test.ts are written. */
|
|
87
88
|
outDir?: string;
|
|
@@ -143,6 +144,7 @@ export async function generate(opts: GenerateOptions): Promise<GenerateResult> {
|
|
|
143
144
|
sharedModules: opts.sharedModules,
|
|
144
145
|
toolPlan: opts.toolPlan,
|
|
145
146
|
revisionMode: opts.revisionMode,
|
|
147
|
+
preTriagedSession: opts.preTriagedSession,
|
|
146
148
|
});
|
|
147
149
|
|
|
148
150
|
setSpanAttributes(span, {
|
|
@@ -343,6 +345,9 @@ const HEADER_TRUNCATE_LIMIT = 200;
|
|
|
343
345
|
// data-bearing POSTs (search/booking) from telemetry; full bodies on a busy
|
|
344
346
|
// site can total >1MB and blow the 200K-token cap on `claude-opus-4-8`.
|
|
345
347
|
const TRIAGE_BODY_LIMIT = 500;
|
|
348
|
+
const EFFECT_TRIAGE_BODY_LIMIT = 800;
|
|
349
|
+
// Leave headroom for narration and browser-action context in every effect pass.
|
|
350
|
+
const EFFECT_TRIAGE_BATCH_CHARS = 300_000;
|
|
346
351
|
const TRIAGE_ACTION_ALIGNMENT_BEFORE_MS = 1000;
|
|
347
352
|
const TRIAGE_ACTION_ALIGNMENT_AFTER_MS = 5000;
|
|
348
353
|
const TRIAGE_CONTEXT_EVENT_TYPES = new Set<Session['events'][number]['type']>([
|
|
@@ -351,6 +356,7 @@ const TRIAGE_CONTEXT_EVENT_TYPES = new Set<Session['events'][number]['type']>([
|
|
|
351
356
|
'input',
|
|
352
357
|
'change',
|
|
353
358
|
'submit',
|
|
359
|
+
'ws-sent',
|
|
354
360
|
]);
|
|
355
361
|
const TRIAGE_ACTION_EVENT_TYPES = new Set<Session['events'][number]['type']>([
|
|
356
362
|
'input',
|
|
@@ -361,6 +367,18 @@ const TRIAGE_ACTION_EVENT_TYPES = new Set<Session['events'][number]['type']>([
|
|
|
361
367
|
export interface TriageResult {
|
|
362
368
|
session: Session;
|
|
363
369
|
selectedSeqs: number[];
|
|
370
|
+
/** Every full-inventory request covered by v2 triage except those classified
|
|
371
|
+
* irreversible. Independent of compile relevance. */
|
|
372
|
+
replaySafeSeqs: number[];
|
|
373
|
+
/** Full-inventory requests that are irreversible if
|
|
374
|
+
* re-issued (place order, charge, send, delete). Used to block them during
|
|
375
|
+
* replay and to flag the compiled tool so compile-verify + audit don't
|
|
376
|
+
* trigger the real action. */
|
|
377
|
+
irreversibleSeqs: number[];
|
|
378
|
+
/** Outbound WebSocket events shown to the effect classifier. */
|
|
379
|
+
coveredOutboundEventSeqs: number[];
|
|
380
|
+
/** Outbound WebSocket events whose replay can cause an irreversible effect. */
|
|
381
|
+
irreversibleEventSeqs: number[];
|
|
364
382
|
consideredCount: number;
|
|
365
383
|
inputTokens: number | null;
|
|
366
384
|
outputTokens: number | null;
|
|
@@ -377,10 +395,12 @@ interface TriageRequestContext {
|
|
|
377
395
|
mimeType?: string;
|
|
378
396
|
headers: string;
|
|
379
397
|
body?: string;
|
|
398
|
+
urlDigest?: string;
|
|
380
399
|
bodyDigest?: string;
|
|
381
400
|
bodyLength?: number;
|
|
382
401
|
responseBodyDigest?: string;
|
|
383
402
|
responseBodyLength?: number;
|
|
403
|
+
responsePreview?: string;
|
|
384
404
|
repeatCount?: number;
|
|
385
405
|
repeatedSeqs?: number[];
|
|
386
406
|
lastTimestamp?: number;
|
|
@@ -393,6 +413,67 @@ interface TriageEventContext {
|
|
|
393
413
|
detail: string;
|
|
394
414
|
}
|
|
395
415
|
|
|
416
|
+
export function parseTriageSelectionResponse(text: string): {
|
|
417
|
+
keepSeqs: number[];
|
|
418
|
+
irreversibleSeqs: number[];
|
|
419
|
+
irreversibleEventSeqs: number[];
|
|
420
|
+
} {
|
|
421
|
+
const isNumArray = (v: unknown): v is number[] =>
|
|
422
|
+
Array.isArray(v) && v.every((s) => typeof s === 'number');
|
|
423
|
+
|
|
424
|
+
const objText = extractJsonObject(text);
|
|
425
|
+
if (objText) {
|
|
426
|
+
let parsed: unknown;
|
|
427
|
+
try {
|
|
428
|
+
parsed = JSON.parse(objText);
|
|
429
|
+
} catch (err) {
|
|
430
|
+
throw new Error(
|
|
431
|
+
`Triage response object was not valid JSON: ${err instanceof Error ? err.message : String(err)}\nExtracted:\n${objText.slice(0, 500)}`,
|
|
432
|
+
);
|
|
433
|
+
}
|
|
434
|
+
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
|
435
|
+
throw new Error(
|
|
436
|
+
`Triage response object is not an object.\nParsed: ${JSON.stringify(parsed)}`,
|
|
437
|
+
);
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
const record = parsed as {
|
|
441
|
+
keep?: unknown;
|
|
442
|
+
irreversible?: unknown;
|
|
443
|
+
irreversibleEvents?: unknown;
|
|
444
|
+
};
|
|
445
|
+
if (!isNumArray(record.keep)) {
|
|
446
|
+
throw new Error(
|
|
447
|
+
`Triage response field "keep" must be an array of numbers.\nParsed: ${(JSON.stringify(record.keep) ?? String(record.keep)).slice(0, 500)}`,
|
|
448
|
+
);
|
|
449
|
+
}
|
|
450
|
+
if (!isNumArray(record.irreversible)) {
|
|
451
|
+
throw new Error(
|
|
452
|
+
`Triage response field "irreversible" must be an array of numbers.\nParsed: ${(JSON.stringify(record.irreversible) ?? String(record.irreversible)).slice(0, 500)}`,
|
|
453
|
+
);
|
|
454
|
+
}
|
|
455
|
+
if (!isNumArray(record.irreversibleEvents)) {
|
|
456
|
+
throw new Error(
|
|
457
|
+
`Triage response field "irreversibleEvents" must be an array of numbers.\nParsed: ${(JSON.stringify(record.irreversibleEvents) ?? String(record.irreversibleEvents)).slice(0, 500)}`,
|
|
458
|
+
);
|
|
459
|
+
}
|
|
460
|
+
return {
|
|
461
|
+
keepSeqs: record.keep,
|
|
462
|
+
irreversibleSeqs: record.irreversible,
|
|
463
|
+
irreversibleEventSeqs: record.irreversibleEvents,
|
|
464
|
+
};
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
if (!extractJsonArray(text)) {
|
|
468
|
+
throw new Error(
|
|
469
|
+
`Triage LLM did not return the required effect-aware object {"keep": [...], "irreversible": [...]}.\nRaw response:\n${text.slice(0, 1000)}`,
|
|
470
|
+
);
|
|
471
|
+
}
|
|
472
|
+
throw new Error(
|
|
473
|
+
`Triage LLM must return the effect-aware object {"keep": [...], "irreversible": [...]}; legacy arrays are unsafe because they cannot prove irreversible classification.\nRaw response:\n${text.slice(0, 1000)}`,
|
|
474
|
+
);
|
|
475
|
+
}
|
|
476
|
+
|
|
396
477
|
export async function triageRequests(
|
|
397
478
|
session: Session,
|
|
398
479
|
llmConfig?: LLMOptions,
|
|
@@ -404,6 +485,7 @@ export async function triageRequests(
|
|
|
404
485
|
...(context.sharedContext?.loginRequestSeqs ?? []),
|
|
405
486
|
]);
|
|
406
487
|
const candidates = selectTriageCandidateRequests(session, preserveSeqs);
|
|
488
|
+
const keepEligibleSeqs = new Set(candidates.map((request) => request.seq));
|
|
407
489
|
|
|
408
490
|
return await traced(
|
|
409
491
|
'compile.triage_requests',
|
|
@@ -415,38 +497,56 @@ export async function triageRequests(
|
|
|
415
497
|
'imprint.provider': llmConfig?.provider ?? 'auto',
|
|
416
498
|
},
|
|
417
499
|
async (span) => {
|
|
500
|
+
const requestContext = (
|
|
501
|
+
r: Session['requests'][number],
|
|
502
|
+
bodyLimit: number,
|
|
503
|
+
includeResponse = true,
|
|
504
|
+
): TriageRequestContext => ({
|
|
505
|
+
seq: r.seq,
|
|
506
|
+
timestamp: r.timestamp,
|
|
507
|
+
method: r.method,
|
|
508
|
+
url: compactUrlForLlm(r.url),
|
|
509
|
+
resourceType: r.resourceType,
|
|
510
|
+
status: r.response?.status,
|
|
511
|
+
mimeType: r.response?.mimeType,
|
|
512
|
+
headers: truncateHeaders(r.headers),
|
|
513
|
+
body: triageBodySnippet(r.body, bodyLimit),
|
|
514
|
+
urlDigest: requestContextDigest(r.url),
|
|
515
|
+
bodyDigest: requestContextDigest(r.body),
|
|
516
|
+
bodyLength: r.body?.length,
|
|
517
|
+
...(includeResponse
|
|
518
|
+
? {
|
|
519
|
+
responseBodyDigest: requestContextDigest(r.response?.body),
|
|
520
|
+
responseBodyLength: r.response?.body?.length,
|
|
521
|
+
responsePreview: triageBodySnippet(r.response?.body, bodyLimit),
|
|
522
|
+
}
|
|
523
|
+
: {}),
|
|
524
|
+
});
|
|
418
525
|
const compacted = compactRequestContexts(
|
|
419
|
-
|
|
420
|
-
seq: r.seq,
|
|
421
|
-
timestamp: r.timestamp,
|
|
422
|
-
method: r.method,
|
|
423
|
-
url: compactUrlForLlm(r.url),
|
|
424
|
-
resourceType: r.resourceType,
|
|
425
|
-
status: r.response?.status,
|
|
426
|
-
mimeType: r.response?.mimeType,
|
|
427
|
-
headers: truncateHeaders(r.headers),
|
|
428
|
-
body: triageBodySnippet(r.body),
|
|
429
|
-
bodyDigest: requestContextDigest(r.body),
|
|
430
|
-
bodyLength: r.body?.length,
|
|
431
|
-
responseBodyDigest: requestContextDigest(r.response?.body),
|
|
432
|
-
responseBodyLength: r.response?.body?.length,
|
|
433
|
-
})),
|
|
526
|
+
session.requests.map((request) => requestContext(request, EFFECT_TRIAGE_BODY_LIMIT)),
|
|
434
527
|
triageRequestGroupKey,
|
|
435
528
|
{ preserveSeqs },
|
|
436
529
|
);
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
requests: metadata,
|
|
530
|
+
const requestMetadata = (
|
|
531
|
+
request: TriageRequestContext,
|
|
532
|
+
): Omit<TriageRequestContext, 'urlDigest' | 'bodyDigest' | 'responseBodyDigest'> & {
|
|
533
|
+
keepEligible: boolean;
|
|
534
|
+
} => {
|
|
535
|
+
const { urlDigest, bodyDigest, responseBodyDigest, ...rest } = request;
|
|
536
|
+
return {
|
|
537
|
+
...rest,
|
|
538
|
+
keepEligible: compactedRequestSeqs(rest).some((seq) => keepEligibleSeqs.has(seq)),
|
|
539
|
+
};
|
|
448
540
|
};
|
|
449
|
-
const
|
|
541
|
+
const metadata = compacted.map(requestMetadata);
|
|
542
|
+
const coveredSeqs = expandCompactedTriageSeqs(
|
|
543
|
+
compacted.map((request) => request.seq),
|
|
544
|
+
compacted,
|
|
545
|
+
);
|
|
546
|
+
const outboundEvents = buildTriageEventContexts(session).filter(
|
|
547
|
+
(event) => event.type === 'ws-sent',
|
|
548
|
+
);
|
|
549
|
+
const coveredOutboundEventSeqs = outboundEvents.map((event) => event.seq);
|
|
450
550
|
|
|
451
551
|
const promptPath = pathJoin(PROMPTS_DIR, 'request-triage.md');
|
|
452
552
|
if (!existsSync(promptPath)) {
|
|
@@ -455,60 +555,147 @@ export async function triageRequests(
|
|
|
455
555
|
);
|
|
456
556
|
}
|
|
457
557
|
const systemPrompt = readFileSync(promptPath, 'utf8');
|
|
458
|
-
|
|
558
|
+
const llm = resolveProvider(llmConfig ?? {});
|
|
559
|
+
const contextEvents = buildTriageEventContexts(session).filter(
|
|
560
|
+
(event) => event.type !== 'ws-sent',
|
|
561
|
+
);
|
|
562
|
+
const relevanceCompacted = compactRequestContexts(
|
|
563
|
+
candidates.map((request) => requestContext(request, TRIAGE_BODY_LIMIT, false)),
|
|
564
|
+
triageRequestGroupKey,
|
|
565
|
+
{ preserveSeqs },
|
|
566
|
+
);
|
|
567
|
+
const relevancePayload = {
|
|
568
|
+
mode: 'relevance',
|
|
569
|
+
site: session.site,
|
|
570
|
+
url: compactUrlForLlm(session.url),
|
|
571
|
+
narration: session.narration,
|
|
572
|
+
events: contextEvents,
|
|
573
|
+
requests: relevanceCompacted.map(requestMetadata),
|
|
574
|
+
outboundWebSockets: [],
|
|
575
|
+
};
|
|
459
576
|
log(
|
|
460
|
-
`triaging ${
|
|
577
|
+
`triaging ${relevanceCompacted.length} relevance candidates; ${Math.round(JSON.stringify(relevancePayload).length / 1024)} KB payload…`,
|
|
461
578
|
);
|
|
462
|
-
const
|
|
463
|
-
const
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
579
|
+
const relevanceResult = await llm.analyze(systemPrompt, relevancePayload);
|
|
580
|
+
const { keepSeqs } = parseTriageSelectionResponse(relevanceResult.text);
|
|
581
|
+
const candidateSet = new Set(
|
|
582
|
+
expandCompactedTriageSeqs(
|
|
583
|
+
relevanceCompacted.map((request) => request.seq),
|
|
584
|
+
relevanceCompacted,
|
|
585
|
+
),
|
|
586
|
+
);
|
|
587
|
+
const unknownKeepSeqs = keepSeqs.filter((seq) => !candidateSet.has(seq));
|
|
588
|
+
if (unknownKeepSeqs.length > 0) {
|
|
467
589
|
throw new Error(
|
|
468
|
-
`Triage
|
|
590
|
+
`Triage response referenced request seq(s) absent from its relevance inventory: ${[...new Set(unknownKeepSeqs)].join(', ')}.`,
|
|
469
591
|
);
|
|
470
592
|
}
|
|
471
593
|
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
594
|
+
const safetyItems = [
|
|
595
|
+
...metadata.map((request) => ({ kind: 'request' as const, value: request })),
|
|
596
|
+
...outboundEvents.map((event) => ({ kind: 'websocket' as const, value: event })),
|
|
597
|
+
];
|
|
598
|
+
const safetyBatches = chunkTriageItems(safetyItems, EFFECT_TRIAGE_BATCH_CHARS);
|
|
599
|
+
const irreversibleSeqs: number[] = [];
|
|
600
|
+
const irreversibleEventSeqs: number[] = [];
|
|
601
|
+
let inputTokens = relevanceResult.inputTokens;
|
|
602
|
+
let outputTokens = relevanceResult.outputTokens;
|
|
603
|
+
let durationMs = relevanceResult.durationMs;
|
|
604
|
+
let safetyPayloadChars = 0;
|
|
605
|
+
for (const [batchIndex, batch] of safetyBatches.entries()) {
|
|
606
|
+
const batchRequests = batch
|
|
607
|
+
.filter((item) => item.kind === 'request')
|
|
608
|
+
.map((item) => item.value);
|
|
609
|
+
const batchWebSockets = batch
|
|
610
|
+
.filter((item) => item.kind === 'websocket')
|
|
611
|
+
.map((item) => item.value);
|
|
612
|
+
const safetyPayload = {
|
|
613
|
+
mode: 'effect',
|
|
614
|
+
batch: { index: batchIndex + 1, total: safetyBatches.length },
|
|
615
|
+
site: session.site,
|
|
616
|
+
url: compactUrlForLlm(session.url),
|
|
617
|
+
narration: session.narration,
|
|
618
|
+
events: contextEvents,
|
|
619
|
+
requests: batchRequests,
|
|
620
|
+
outboundWebSockets: batchWebSockets,
|
|
621
|
+
};
|
|
622
|
+
safetyPayloadChars += JSON.stringify(safetyPayload).length;
|
|
623
|
+
const result = await llm.analyze(systemPrompt, safetyPayload);
|
|
624
|
+
const parsed = parseTriageSelectionResponse(result.text);
|
|
625
|
+
const batchRequestSeqs = new Set(
|
|
626
|
+
batchRequests.flatMap((request) => compactedRequestSeqs(request)),
|
|
627
|
+
);
|
|
628
|
+
const batchEventSeqs = new Set(batchWebSockets.map((event) => event.seq));
|
|
629
|
+
const unknownRequests = parsed.irreversibleSeqs.filter((seq) => !batchRequestSeqs.has(seq));
|
|
630
|
+
const unknownEvents = parsed.irreversibleEventSeqs.filter(
|
|
631
|
+
(seq) => !batchEventSeqs.has(seq),
|
|
478
632
|
);
|
|
633
|
+
if (unknownRequests.length > 0 || unknownEvents.length > 0) {
|
|
634
|
+
throw new Error(
|
|
635
|
+
`Effect triage batch ${batchIndex + 1} referenced item(s) absent from its inventory: ${[...new Set([...unknownRequests, ...unknownEvents])].join(', ')}.`,
|
|
636
|
+
);
|
|
637
|
+
}
|
|
638
|
+
irreversibleSeqs.push(...parsed.irreversibleSeqs);
|
|
639
|
+
irreversibleEventSeqs.push(...parsed.irreversibleEventSeqs);
|
|
640
|
+
inputTokens = sumOptionalTokens(inputTokens, result.inputTokens);
|
|
641
|
+
outputTokens = sumOptionalTokens(outputTokens, result.outputTokens);
|
|
642
|
+
durationMs += result.durationMs;
|
|
479
643
|
}
|
|
480
644
|
|
|
481
|
-
|
|
645
|
+
const coveredSet = new Set(coveredSeqs);
|
|
646
|
+
const unknownOutputSeqs = irreversibleSeqs.filter((seq) => !coveredSet.has(seq));
|
|
647
|
+
if (unknownOutputSeqs.length > 0) {
|
|
482
648
|
throw new Error(
|
|
483
|
-
`Triage response
|
|
649
|
+
`Triage response referenced request seq(s) absent from its complete inventory: ${[...new Set(unknownOutputSeqs)].join(', ')}.`,
|
|
484
650
|
);
|
|
485
651
|
}
|
|
486
652
|
|
|
487
|
-
const rescuedSeqs = rescueActionAlignedRepeatedSeqs(session,
|
|
488
|
-
const selectedSet = new Set([...
|
|
653
|
+
const rescuedSeqs = rescueActionAlignedRepeatedSeqs(session, keepSeqs as number[], compacted);
|
|
654
|
+
const selectedSet = new Set([...keepSeqs, ...rescuedSeqs, ...preserveSeqs]);
|
|
655
|
+
const irreversibleSet = new Set(expandCompactedTriageSeqs(irreversibleSeqs, compacted));
|
|
656
|
+
const irreversibleEventSet = new Set(irreversibleEventSeqs);
|
|
657
|
+
const replaySafeSeqs = coveredSeqs.filter((seq) => !irreversibleSet.has(seq));
|
|
489
658
|
const triaged: Session = {
|
|
490
659
|
...session,
|
|
491
|
-
|
|
660
|
+
triage: {
|
|
661
|
+
effectSchemaVersion: 2,
|
|
662
|
+
coveredSeqs,
|
|
663
|
+
irreversibleSeqs: [...irreversibleSet].sort((a, b) => a - b),
|
|
664
|
+
coveredOutboundEventSeqs,
|
|
665
|
+
irreversibleEventSeqs: [...irreversibleEventSet].sort((a, b) => a - b),
|
|
666
|
+
},
|
|
667
|
+
requests: session.requests
|
|
668
|
+
.filter((r) => selectedSet.has(r.seq))
|
|
669
|
+
.map((r) => (irreversibleSet.has(r.seq) ? { ...r, effect: 'irreversible' as const } : r)),
|
|
492
670
|
};
|
|
493
671
|
|
|
494
|
-
log(
|
|
672
|
+
log(
|
|
673
|
+
`triage selected ${selectedSet.size} requests out of ${candidates.length} relevance candidates (${irreversibleSet.size} irreversible requests and ${irreversibleEventSet.size} irreversible outbound WebSocket events across ${safetyBatches.length} bounded safety batch(es))`,
|
|
674
|
+
);
|
|
495
675
|
|
|
496
676
|
setSpanAttributes(span, {
|
|
497
677
|
'imprint.requests_compacted': metadata.length,
|
|
498
678
|
'imprint.requests_selected': selectedSet.size,
|
|
499
|
-
'imprint.triage.payload_chars':
|
|
500
|
-
|
|
501
|
-
'imprint.
|
|
502
|
-
'imprint.
|
|
679
|
+
'imprint.triage.payload_chars':
|
|
680
|
+
JSON.stringify(relevancePayload).length + safetyPayloadChars,
|
|
681
|
+
'imprint.requests_irreversible': irreversibleSet.size,
|
|
682
|
+
'imprint.events_irreversible': irreversibleEventSet.size,
|
|
683
|
+
'imprint.triage.duration_ms': durationMs,
|
|
684
|
+
'imprint.triage.input_tokens': inputTokens,
|
|
685
|
+
'imprint.triage.output_tokens': outputTokens,
|
|
503
686
|
});
|
|
504
687
|
|
|
505
688
|
return {
|
|
506
689
|
session: triaged,
|
|
507
690
|
selectedSeqs: [...selectedSet],
|
|
691
|
+
replaySafeSeqs,
|
|
692
|
+
irreversibleSeqs: [...irreversibleSet],
|
|
693
|
+
coveredOutboundEventSeqs,
|
|
694
|
+
irreversibleEventSeqs: [...irreversibleEventSet],
|
|
508
695
|
consideredCount: candidates.length,
|
|
509
|
-
inputTokens
|
|
510
|
-
outputTokens
|
|
511
|
-
durationMs
|
|
696
|
+
inputTokens,
|
|
697
|
+
outputTokens,
|
|
698
|
+
durationMs,
|
|
512
699
|
};
|
|
513
700
|
},
|
|
514
701
|
);
|
|
@@ -525,6 +712,28 @@ export function buildTriageEventContexts(session: Session): TriageEventContext[]
|
|
|
525
712
|
}));
|
|
526
713
|
}
|
|
527
714
|
|
|
715
|
+
export function chunkTriageItems<T>(items: T[], maxChars: number): T[][] {
|
|
716
|
+
const batches: T[][] = [];
|
|
717
|
+
let current: T[] = [];
|
|
718
|
+
let currentChars = 2;
|
|
719
|
+
for (const item of items) {
|
|
720
|
+
const itemChars = JSON.stringify(item).length + 1;
|
|
721
|
+
if (current.length > 0 && currentChars + itemChars > maxChars) {
|
|
722
|
+
batches.push(current);
|
|
723
|
+
current = [];
|
|
724
|
+
currentChars = 2;
|
|
725
|
+
}
|
|
726
|
+
current.push(item);
|
|
727
|
+
currentChars += itemChars;
|
|
728
|
+
}
|
|
729
|
+
if (current.length > 0 || batches.length === 0) batches.push(current);
|
|
730
|
+
return batches;
|
|
731
|
+
}
|
|
732
|
+
|
|
733
|
+
function sumOptionalTokens(left: number | null, right: number | null): number | null {
|
|
734
|
+
return left === null && right === null ? null : (left ?? 0) + (right ?? 0);
|
|
735
|
+
}
|
|
736
|
+
|
|
528
737
|
export function selectTriageCandidateRequests(
|
|
529
738
|
session: Session,
|
|
530
739
|
preserveSeqs: Iterable<number> = [],
|
|
@@ -537,6 +746,29 @@ export function selectTriageCandidateRequests(
|
|
|
537
746
|
});
|
|
538
747
|
}
|
|
539
748
|
|
|
749
|
+
function compactedRequestSeqs(
|
|
750
|
+
request: Pick<TriageRequestContext, 'seq' | 'repeatedSeqs'>,
|
|
751
|
+
): number[] {
|
|
752
|
+
return [...new Set([request.seq, ...(request.repeatedSeqs ?? [])])];
|
|
753
|
+
}
|
|
754
|
+
|
|
755
|
+
/** Expand a classification on any representative/member of a compacted row to
|
|
756
|
+
* every original request represented by that row. Effect decisions must apply
|
|
757
|
+
* uniformly because the LLM saw only one compacted request description. */
|
|
758
|
+
export function expandCompactedTriageSeqs(
|
|
759
|
+
seqs: Iterable<number>,
|
|
760
|
+
compactedRequests: Pick<TriageRequestContext, 'seq' | 'repeatedSeqs'>[],
|
|
761
|
+
): number[] {
|
|
762
|
+
const requested = new Set(seqs);
|
|
763
|
+
const expanded = new Set(requested);
|
|
764
|
+
for (const request of compactedRequests) {
|
|
765
|
+
const group = compactedRequestSeqs(request);
|
|
766
|
+
if (!group.some((seq) => requested.has(seq))) continue;
|
|
767
|
+
for (const seq of group) expanded.add(seq);
|
|
768
|
+
}
|
|
769
|
+
return [...expanded].sort((a, b) => a - b);
|
|
770
|
+
}
|
|
771
|
+
|
|
540
772
|
export function rescueActionAlignedRepeatedSeqs(
|
|
541
773
|
session: Session,
|
|
542
774
|
selectedSeqs: Iterable<number>,
|
|
@@ -609,6 +841,7 @@ function triageRequestGroupKey(request: TriageRequestContext): unknown[] {
|
|
|
609
841
|
request.resourceType,
|
|
610
842
|
request.status,
|
|
611
843
|
request.mimeType,
|
|
844
|
+
request.urlDigest,
|
|
612
845
|
request.bodyDigest,
|
|
613
846
|
];
|
|
614
847
|
}
|
|
@@ -619,9 +852,12 @@ function truncateHeaders(headers: Record<string, string>): string {
|
|
|
619
852
|
return `${serialized.slice(0, HEADER_TRUNCATE_LIMIT)}…`;
|
|
620
853
|
}
|
|
621
854
|
|
|
622
|
-
export function triageBodySnippet(
|
|
855
|
+
export function triageBodySnippet(
|
|
856
|
+
body: string | undefined,
|
|
857
|
+
maxChars = TRIAGE_BODY_LIMIT,
|
|
858
|
+
): string | undefined {
|
|
623
859
|
if (body === undefined) return undefined;
|
|
624
|
-
if (isLikelyText(body)) return truncate(body,
|
|
860
|
+
if (isLikelyText(body)) return truncate(body, maxChars);
|
|
625
861
|
return `[non-text request body omitted; original length ${body.length}]`;
|
|
626
862
|
}
|
|
627
863
|
|
|
@@ -752,17 +988,10 @@ async function compilePlaybookImpl(opts: CompileOptions): Promise<CompilePlayboo
|
|
|
752
988
|
durationMs: 0,
|
|
753
989
|
};
|
|
754
990
|
if (opts.preTriagedSession && !opts.noShrink) {
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
...(opts.sharedContext?.loginRequestSeqs ?? []),
|
|
760
|
-
]);
|
|
761
|
-
const finalSeqs = new Set([...opts.preTriagedSession.selectedSeqs, ...preserveSeqs]);
|
|
762
|
-
session = {
|
|
763
|
-
...session,
|
|
764
|
-
requests: session.requests.filter((r) => finalSeqs.has(r.seq)),
|
|
765
|
-
};
|
|
991
|
+
session = applySharedTriageSelection(session, opts.preTriagedSession, {
|
|
992
|
+
candidate: opts.candidate,
|
|
993
|
+
sharedContext: opts.sharedContext,
|
|
994
|
+
});
|
|
766
995
|
log('using shared triage result (skipping per-tool triage LLM call)');
|
|
767
996
|
triageTokens = {
|
|
768
997
|
input: opts.preTriagedSession.inputTokens,
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import type { Workflow } from './types.ts';
|
|
2
|
+
|
|
3
|
+
export function isIrreversibleRequest(request: { effect?: string }): boolean {
|
|
4
|
+
return request.effect === 'irreversible';
|
|
5
|
+
}
|
|
6
|
+
|
|
7
|
+
export function workflowHasIrreversibleEffect(workflow: Workflow): boolean {
|
|
8
|
+
return workflow.requests.some(isIrreversibleRequest);
|
|
9
|
+
}
|