|
|
|
@@ -14,6 +14,9 @@ const hash = value => createHash('sha256').update(typeof value === 'string' ? va
|
|
|
|
|
const PLACEHOLDER_ID = '00000000-0000-0000-0000-000000000000';
|
|
|
|
|
const PLACEHOLDER_SHA = '0'.repeat(64);
|
|
|
|
|
const ARCHIVE_CHARACTERS = 1_000_000;
|
|
|
|
|
const completeSmallSource = candidate => candidate.observation.kind === 'file' && candidate.observation.content.length <= 6000
|
|
|
|
|
&& (candidate.observation.offset === undefined || candidate.observation.offset === 0
|
|
|
|
|
&& candidate.observation.next_offset === candidate.observation.total_characters);
|
|
|
|
|
|
|
|
|
|
function protocolError(message) {
|
|
|
|
|
const error = new Error('请求上下文协议需要核对:' + message);
|
|
|
|
@@ -57,12 +60,21 @@ export function budgetFor(config, run, task, transportReservationTokens = 0) {
|
|
|
|
|
const remaining = (maximum, usage) => maximum > 0 ? Math.max(0, maximum - accountedTokens(usage)) : null;
|
|
|
|
|
const runRemainingTokens = remaining(run?.budget?.maxTokens, run?.usage);
|
|
|
|
|
const taskRemainingTokens = remaining(task?.budget?.maxTokens, task?.usage);
|
|
|
|
|
let limit = config.contextLimit, reason = 'context_limit';
|
|
|
|
|
if (runRemainingTokens !== null && runRemainingTokens < limit) { limit = runRemainingTokens; reason = 'token_limit'; }
|
|
|
|
|
if (taskRemainingTokens !== null && taskRemainingTokens < limit) { limit = taskRemainingTokens; reason = 'task_token_limit'; }
|
|
|
|
|
if(!Number.isSafeInteger(transportReservationTokens)||transportReservationTokens<0)throw new Error('请求封装预留无效。');
|
|
|
|
|
const inputBudget = limit - outputReservation - safetyTokens - transportReservationTokens;
|
|
|
|
|
// A shared prompt must fit every route, but each context window is paired
|
|
|
|
|
// with that route's own output. Combining one member's small context with
|
|
|
|
|
// another member's large output can reject a pool that actually fits.
|
|
|
|
|
const routeInputBudgets = config.capacityMode === 'model' && config.modelRouting?.members?.length
|
|
|
|
|
? config.modelRouting.members.map(member => ({ connectionId: member.id, contextLimit: member.contextLimit,
|
|
|
|
|
outputReservation: member.maxOutputTokens, inputBudget: member.contextLimit - member.maxOutputTokens - safetyTokens - transportReservationTokens })) : null;
|
|
|
|
|
let inputBudget = routeInputBudgets ? Math.min(...routeInputBudgets.map(route => route.inputBudget))
|
|
|
|
|
: config.contextLimit - outputReservation - safetyTokens - transportReservationTokens;
|
|
|
|
|
let reason = 'context_limit';
|
|
|
|
|
const afterOutput = credit => credit - outputReservation - safetyTokens - transportReservationTokens;
|
|
|
|
|
if (runRemainingTokens !== null && afterOutput(runRemainingTokens) < inputBudget) { inputBudget = afterOutput(runRemainingTokens); reason = 'token_limit'; }
|
|
|
|
|
if (taskRemainingTokens !== null && afterOutput(taskRemainingTokens) < inputBudget) { inputBudget = afterOutput(taskRemainingTokens); reason = 'task_token_limit'; }
|
|
|
|
|
return { contextLimit: config.contextLimit, outputReservation, safetyTokens, ...(transportReservationTokens?{transportReservationTokens}:{}), inputBudget, targetInputTokens: config.capacityMode === 'model' ? inputBudget : Math.min(16000, inputBudget),
|
|
|
|
|
...(routeInputBudgets ? { routeInputBudgets } : {}),
|
|
|
|
|
runRemainingTokens, taskRemainingTokens, limitingReason: reason };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@@ -190,7 +202,8 @@ export class RequestPlanner {
|
|
|
|
|
if (preserve && before.estimatedInputTokens > budget.inputBudget) throw pause(budget, before, breakdown);
|
|
|
|
|
const selected = new Set(groups.map(group => group.index));
|
|
|
|
|
let omitted = [], reference = null, workingReference = null, latestReference = null;
|
|
|
|
|
const latestDocument = latestToolDocument(this.store, session, run, groups, 3);
|
|
|
|
|
let latestViewVersion = 3;
|
|
|
|
|
let latestDocument = latestToolDocument(this.store, session, run, groups, latestViewVersion);
|
|
|
|
|
const entries = [];
|
|
|
|
|
let retainedSources = [];
|
|
|
|
|
// A read locator already carried in raw history, latest feedback or the
|
|
|
|
@@ -206,17 +219,34 @@ export class RequestPlanner {
|
|
|
|
|
const metricsFor = (indices, includeNotice = true, currentEntries = entries, includeLatest = true) => {
|
|
|
|
|
const missing = groups.filter(group => !indices.has(group.index));
|
|
|
|
|
const messages = [fixed, ...(missing.length && includeNotice ? [notice({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, missing, descriptions, unsentEvidence(indices, currentEntries, includeLatest))] : []),
|
|
|
|
|
...(includeLatest && latestDocument && !indices.has(latestDocument.group_index) ? [latestToolMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, latestDocument, 3)] : []),
|
|
|
|
|
...(includeLatest && latestDocument && !indices.has(latestDocument.group_index) ? [latestToolMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, latestDocument, latestViewVersion)] : []),
|
|
|
|
|
...(currentEntries.length ? [workingMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, workingDocument(session, run, currentEntries, 3), 4)] : []),
|
|
|
|
|
...groups.filter(group => indices.has(group.index)).flatMap(group => group.messages), ...tail];
|
|
|
|
|
return requestMetrics(completionBody(config, messages, tools));
|
|
|
|
|
};
|
|
|
|
|
if (!preserve && before.estimatedInputTokens > budget.targetInputTokens) {
|
|
|
|
|
selected.clear(); if (lastUser) selected.add(lastUser.index);
|
|
|
|
|
const observed = workingCandidates(this.store, session, run, groups, 3);
|
|
|
|
|
// Keep the established compact layout whenever complete small sources
|
|
|
|
|
// fit. Under pressure the latest-result envelope can itself carry small
|
|
|
|
|
// original reads, avoiding an extra working envelope for each of them.
|
|
|
|
|
const smallSources = observed.filter(completeSmallSource)
|
|
|
|
|
.slice(0, 12).map(candidate => workingEntry(candidate, candidate.observation.content.length));
|
|
|
|
|
if (smallSources.length && metricsFor(selected, true, smallSources).estimatedInputTokens > budget.inputBudget) {
|
|
|
|
|
const withExcerpts = latestToolDocument(this.store, session, run, groups, 4);
|
|
|
|
|
if (withExcerpts?.entries.some(entry => typeof entry.result.content_excerpt === 'string')) {
|
|
|
|
|
latestViewVersion = 4; latestDocument = withExcerpts;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
const mandatory = metricsFor(selected);
|
|
|
|
|
if (mandatory.estimatedInputTokens > budget.inputBudget) throw pause(budget, mandatory, breakdown);
|
|
|
|
|
const observed = workingCandidates(this.store, session, run, groups, 3);
|
|
|
|
|
const coveredByRaw = entry => (entry.fragments ?? [entry.source]).every(source => selected.has(source.group_index));
|
|
|
|
|
// A complete small read can travel with its latest result. Do not spend
|
|
|
|
|
// another provenance envelope to repeat those same source bytes. Longer
|
|
|
|
|
// reads and assembled ranges still need their own working observation.
|
|
|
|
|
const coveredByLatest = entry => entry.observation.kind === 'file' && !entry.fragments
|
|
|
|
|
&& latestDocument?.entries.some(latest => latest.source.call_id === entry.source.call_id
|
|
|
|
|
&& latest.result.content_excerpt === entry.observation.content);
|
|
|
|
|
// Admit complete small source observations before optional raw history.
|
|
|
|
|
// A reservation alone does not keep code in the actual sent request.
|
|
|
|
|
const newest = groups.at(-1);
|
|
|
|
@@ -227,13 +257,15 @@ export class RequestPlanner {
|
|
|
|
|
selected.add(newest.index);
|
|
|
|
|
if (metricsFor(selected).estimatedInputTokens > budget.inputBudget) selected.delete(newest.index);
|
|
|
|
|
}
|
|
|
|
|
for (const candidate of observed.filter(candidate => candidate.observation.kind === 'file' && candidate.observation.content.length <= 6000)) {
|
|
|
|
|
for (const candidate of observed.filter(completeSmallSource)) {
|
|
|
|
|
if (entries.length >= 12) break;
|
|
|
|
|
if (coveredByRaw(candidate)) continue;
|
|
|
|
|
const entry = workingEntry(candidate, candidate.observation.content.length);
|
|
|
|
|
if (metricsFor(selected, true, [...entries, entry]).estimatedInputTokens <= retentionTarget) entries.push(entry);
|
|
|
|
|
}
|
|
|
|
|
retainedSources = [...entries];
|
|
|
|
|
retainedSources = [...entries, ...observed.filter(candidate => coveredByLatest(candidate)
|
|
|
|
|
&& !entries.some(entry => entry.source.call_id === candidate.source.call_id))
|
|
|
|
|
.map(candidate => workingEntry(candidate, candidate.observation.content.length))];
|
|
|
|
|
const newestUseful = newest?.messages.every(message => {
|
|
|
|
|
if (message.role !== 'tool') return true;
|
|
|
|
|
try { const result = JSON.parse(message.content); return !result.kind?.startsWith('context-') && result.kind !== 'tool-result'; } catch { return true; }
|
|
|
|
@@ -253,12 +285,12 @@ export class RequestPlanner {
|
|
|
|
|
};
|
|
|
|
|
// A small result in a mixed large group must remain usable. It is a
|
|
|
|
|
// separate, provenance-checked observation, never a broken tool pair.
|
|
|
|
|
const candidates = observed.filter(candidate => !coveredByRaw(candidate)
|
|
|
|
|
const candidates = observed.filter(candidate => !coveredByRaw(candidate) && !coveredByLatest(candidate)
|
|
|
|
|
&& !entries.some(entry => entry.source.call_id === candidate.source.call_id));
|
|
|
|
|
for (const [index, candidate] of candidates.entries()) {
|
|
|
|
|
if (entries.length >= 12) break;
|
|
|
|
|
const remaining = target - metricsFor(selected).estimatedInputTokens;
|
|
|
|
|
const smallFile = candidate.observation.kind === 'file' && candidate.observation.content.length <= 6000;
|
|
|
|
|
const smallFile = completeSmallSource(candidate);
|
|
|
|
|
const share = Math.max(128, Math.floor(remaining / Math.max(1, candidates.length - index)));
|
|
|
|
|
const maximum = Math.min(candidate.observation.content.length, 12000, smallFile ? candidate.observation.content.length : share * 2);
|
|
|
|
|
let low = 0, high = maximum;
|
|
|
|
@@ -291,7 +323,7 @@ export class RequestPlanner {
|
|
|
|
|
if (entries.length) workingReference = this.artifact(session, run, workingDocument(session, run, entries, 3), 'context-working-set');
|
|
|
|
|
if (latestDocument && !selected.has(latestDocument.group_index)) latestReference = this.artifact(session, run, latestDocument, 'context-latest-tools');
|
|
|
|
|
const messages = [fixed, ...(reference ? [notice(reference, omitted, descriptions, unsentEvidence(selected, entries, true))] : []),
|
|
|
|
|
...(latestReference ? [latestToolMessage(latestReference, latestDocument, 3)] : []),
|
|
|
|
|
...(latestReference ? [latestToolMessage(latestReference, latestDocument, latestViewVersion)] : []),
|
|
|
|
|
...(workingReference ? [workingMessage(workingReference, workingDocument(session, run, entries, 3), 4)] : []),
|
|
|
|
|
...structuredClone(groups.filter(group => selected.has(group.index)).flatMap(group => group.messages)), ...tail];
|
|
|
|
|
let mcpReference = null, mcpDocument = null;
|
|
|
|
@@ -366,16 +398,20 @@ export class RequestPlanner {
|
|
|
|
|
// The next result replaces the current latest-result feedback. Do not
|
|
|
|
|
// reserve both views when sizing that result's actual protocol page.
|
|
|
|
|
nextReadFixedInputTokens: metricsFor(new Set(lastUser ? [lastUser.index] : []), true, [], false).estimatedInputTokens,
|
|
|
|
|
workingRetentionTokens: Math.max(0, metricsFor(new Set(lastUser ? [lastUser.index] : []), true, retainedSources).estimatedInputTokens
|
|
|
|
|
- metricsFor(new Set(lastUser ? [lastUser.index] : []), true, []).estimatedInputTokens),
|
|
|
|
|
workingRetentionPolicyVersion: 1,
|
|
|
|
|
workingRetentionTokens: Math.max(0, metricsFor(new Set(lastUser ? [lastUser.index] : []), true, retainedSources, latestViewVersion === 3).estimatedInputTokens
|
|
|
|
|
- metricsFor(new Set(lastUser ? [lastUser.index] : []), true, [], latestViewVersion === 3).estimatedInputTokens),
|
|
|
|
|
workingRetentionPolicyVersion: latestViewVersion === 4 ? 2 : 1,
|
|
|
|
|
readBudgetPolicyVersion: 3,
|
|
|
|
|
// Routing, read coverage and recent-tool state grow after a reply. Page
|
|
|
|
|
// sizing reserves that observed framing growth before returning bytes;
|
|
|
|
|
// the next complete request is still checked against its original limit.
|
|
|
|
|
readStateGrowthTokens: 1536,
|
|
|
|
|
originalMessages: session.providerMessages.length, retainedMessages: messages.length - 1 - tail.length - (reference ? 1 : 0) - (workingReference ? 1 : 0) - (latestReference ? 1 : 0) - (memoryReference ? 1 : 0) - (skillReference ? 1 : 0) - (mcpReference ? 1 : 0),
|
|
|
|
|
archivedGroups: omitted.length, retainedGroups: groups.filter(group => selected.has(group.index)).map(group => group.index),
|
|
|
|
|
historyIndexArtifactId: reference?.id ?? null, historyIndexSha256: reference?.sha256 ?? null, actualUsage: null,
|
|
|
|
|
workingSetArtifactId: workingReference?.id ?? null, workingSetSha256: workingReference?.sha256 ?? null, workingSetEntries: entries.length,
|
|
|
|
|
workingSetViewVersion: 4,
|
|
|
|
|
latestToolsViewVersion: 3,
|
|
|
|
|
latestToolsViewVersion: latestViewVersion,
|
|
|
|
|
latestToolsArtifactId: latestReference?.id ?? null, latestToolsSha256: latestReference?.sha256 ?? null, latestToolsEntries: latestReference ? latestDocument.entries.length : 0,
|
|
|
|
|
projectMemoryArtifactId: memoryReference?.id ?? null, projectMemorySha256: memoryReference?.sha256 ?? null,
|
|
|
|
|
projectMemoryEntries: memoryReference ? memoryDocument.entries.length : 0,
|
|
|
|
@@ -409,10 +445,15 @@ export function verifyPlanEvidence(store, session, plan, cache = new Map()) {
|
|
|
|
|
};
|
|
|
|
|
const request = get(plan.requestArtifactId, 'model-request', plan.requestSha256);
|
|
|
|
|
const body = JSON.parse(store.artifactStore.read(request)), metrics = requestMetrics(body);
|
|
|
|
|
const runModel = store.owned('run', plan.runId, session.id).model;
|
|
|
|
|
if(plan.tokenReservation)verifyModelReservation(store,session,plan.taskId,{...store.owned('run',plan.runId,session.id).model,
|
|
|
|
|
modelRouting:store.owned('run',plan.runId,session.id).model.routing},body,plan.tokenReservation);
|
|
|
|
|
const invalidOutput = body.kind === 'model-route-plan' && runModel.capacityMode === 'model'
|
|
|
|
|
? body.variants.some(variant => outputReservation(variant.body) !== runModel.routing?.members.find(member => member.id === variant.connectionId)?.maxOutputTokens)
|
|
|
|
|
|| Math.max(...requestVariants(body).map(outputReservation)) !== plan.budget.outputReservation
|
|
|
|
|
: requestVariants(body).some(value => outputReservation(value) !== plan.budget.outputReservation);
|
|
|
|
|
if (metrics.bytes !== plan.requestBytes || metrics.estimatedInputTokens !== plan.estimatedInputTokens
|
|
|
|
|
|| requestVariants(body).some(value => outputReservation(value) !== plan.budget.outputReservation) || metrics.estimatedInputTokens > plan.budget.inputBudget) throw new Error('请求预算与原正文不匹配。');
|
|
|
|
|
|| invalidOutput || metrics.estimatedInputTokens > plan.budget.inputBudget) throw new Error('请求预算与原正文不匹配。');
|
|
|
|
|
historyGroups(requestHistory(body));
|
|
|
|
|
for (const variant of requestVariants(body)) historyGroups(requestHistory(variant));
|
|
|
|
|
const frozen = JSON.parse(store.artifactStore.read(get(plan.artifactId, 'context-plan')));
|
|
|
|
@@ -465,6 +506,7 @@ export function verifyPlanEvidence(store, session, plan, cache = new Map()) {
|
|
|
|
|
if ((frozen.nextReadFixedInputTokens ?? null) !== (plan.nextReadFixedInputTokens ?? null)) throw new Error('下一工具页的固定预算与封存记录不匹配。');
|
|
|
|
|
if ((frozen.readBudgetPolicyVersion ?? 1) !== (plan.readBudgetPolicyVersion ?? 1)
|
|
|
|
|
|| (frozen.latestToolsViewVersion ?? 1) !== (plan.latestToolsViewVersion ?? 1)) throw new Error('读取或最新反馈视图版本与封存记录不匹配。');
|
|
|
|
|
if ((frozen.readStateGrowthTokens ?? null) !== (plan.readStateGrowthTokens ?? null)) throw new Error('读取状态增长预留与封存记录不匹配。');
|
|
|
|
|
if ((frozen.latestToolsArtifactId ?? null) !== (plan.latestToolsArtifactId ?? null)
|
|
|
|
|
|| (frozen.latestToolsSha256 ?? null) !== (plan.latestToolsSha256 ?? null)
|
|
|
|
|
|| (frozen.latestToolsEntries ?? 0) !== (plan.latestToolsEntries ?? 0)) throw new Error('最新工具反馈与发送前的封存记录不匹配。');
|
|
|
|
|