@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/context/diagnostics.js

@@ -0,0 +1,108 @@
+// Opt-in development observations. Never publish text, identities, or raw data.
+import { channel } from "node:diagnostics_channel";
+export const CONTEXT_DIAGNOSTIC_CHANNEL = "jecode.context";
+const observations = channel(CONTEXT_DIAGNOSTIC_CHANNEL);
+/** Whitelist at the channel boundary; subscribers must not serialize callers. */
+export function safeDiagnostic(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const v = value;
+    if (v["kind"] === "preparation" && (v["reason"] === "budget" || v["reason"] === "overflow") &&
+        (v["outcome"] === "failed" || v["outcome"] === "cancelled") && count(v["elapsedMs"]) &&
+        count(v["windowTokens"]) && count(v["triggerTokens"]) && count(v["requestLimitTokens"])) {
+        return { kind: "preparation", reason: v["reason"], outcome: v["outcome"], elapsedMs: v["elapsedMs"],
+            windowTokens: v["windowTokens"], triggerTokens: v["triggerTokens"], requestLimitTokens: v["requestLimitTokens"] };
+    }
+    if (v["kind"] === "request" &&
+        (v["source"] === "estimate" || v["source"] === "provider-prefix") &&
+        count(v["estimatedTokens"]) && count(v["inputTokens"]) &&
+        (v["reportedInputTokens"] === undefined || count(v["reportedInputTokens"]))) {
+        const extras = {};
+        for (const key of ["windowTokens", "triggerTokens", "requestLimitTokens", "outputBudgetTokens",
+            "preparationMs", "providerMs", "firstEventMs", "clippedResults"]) {
+            if (v[key] !== undefined) {
+                if (!count(v[key]))
+                    return undefined;
+                Object.assign(extras, { [key]: v[key] });
+            }
+        }
+        const result = v["outcome"];
+        if (result !== undefined && result !== "completed" && result !== "failed" && result !== "cancelled")
+            return undefined;
+        const tokenization = v["tokenization"];
+        if (tokenization !== undefined && tokenization !== "o200k-reference" && tokenization !== "heuristic")
+            return undefined;
+        return { ...extras, ...(result === undefined ? {} : { outcome: result }),
+            ...(tokenization === undefined ? {} : { tokenization }),
+            kind: "request", source: v["source"], estimatedTokens: v["estimatedTokens"],
+            inputTokens: v["inputTokens"],
+            ...(v["reportedInputTokens"] === undefined ? {} : { reportedInputTokens: v["reportedInputTokens"] }) };
+    }
+    if (v["kind"] === "compaction" &&
+        (v["reason"] === "budget" || v["reason"] === "overflow" || v["reason"] === "manual") &&
+        outcome(v["outcome"]) && count(v["beforeTokens"]) && count(v["elapsedMs"]) &&
+        (v["afterTokens"] === undefined || count(v["afterTokens"]))) {
+        const limits = {};
+        for (const key of ["windowTokens", "triggerTokens", "requestLimitTokens",
+            "summaryChars", "summaryProviderMs", "firstSummaryTextMs"]) {
+            if (v[key] !== undefined) {
+                if (!count(v[key]))
+                    return undefined;
+                limits[key] = v[key];
+            }
+        }
+        return { ...limits, kind: "compaction", reason: v["reason"], outcome: v["outcome"],
+            beforeTokens: v["beforeTokens"], elapsedMs: v["elapsedMs"],
+            ...(v["afterTokens"] === undefined ? {} : { afterTokens: v["afterTokens"] }) };
+    }
+    return undefined;
+}
+export function publishDiagnostic(event) {
+    if (!observations.hasSubscribers)
+        return;
+    const safe = safeDiagnostic(event);
+    if (safe !== undefined)
+        observations.publish(safe);
+}
+export async function observedCompaction(options, perform) {
+    const started = performance.now();
+    let state = "no-prefix";
+    let result;
+    let summary;
+    try {
+        result = await perform({ ...options,
+            onBegin() { state = "failed"; options.onBegin?.(); },
+            onOutcome(value) { state = value; options.onOutcome?.(value); },
+            onSummary(value) { summary = value; options.onSummary?.(value); },
+        });
+        return result;
+    }
+    catch (error) {
+        if (options.signal?.aborted)
+            state = "cancelled";
+        else if (state === "no-prefix")
+            state = "failed";
+        throw error;
+    }
+    finally {
+        const event = {
+            kind: "compaction", reason: options.reason ?? (options.force ? "manual" : "budget"),
+            outcome: state, beforeTokens: options.estimatedInputTokens ?? 0,
+            windowTokens: options.policy.windowTokens, triggerTokens: options.policy.triggerTokens,
+            requestLimitTokens: options.policy.requestLimitTokens,
+            ...(result === undefined ? {} : { afterTokens: result.estimatedInputTokens }),
+            elapsedMs: Math.round(performance.now() - started),
+            ...summary,
+        };
+        publishDiagnostic(event);
+        options.onDiagnostic?.(event);
+    }
+}
+function count(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function outcome(value) {
+    return value === "accepted" || value === "empty" || value === "oversized" ||
+        value === "insufficient-savings" || value === "failed" || value === "timeout" ||
+        value === "cancelled" || value === "no-prefix";
+}

package/dist/context/lifetime.js

@@ -0,0 +1,18 @@
+// Reuse only the current conversation's meter. No calibration survives restart.
+import { inputMeter } from "./measurement.js";
+export function inputLifetime() {
+    let current;
+    return {
+        forTurn(provider, conversation) {
+            if (current?.provider !== provider || current.conversation !== conversation) {
+                current?.meter.reset();
+                current = { provider, conversation, meter: inputMeter(provider) };
+            }
+            return current.meter;
+        },
+        reset() {
+            current?.meter.reset();
+            current = undefined;
+        },
+    };
+}

package/dist/context/manager.js

@@ -0,0 +1,67 @@
+// One automatic-compaction lifecycle, independent of terminal and persistence.
+import { automaticCompactionKey } from "./automatic.js";
+import { compactContext } from "./compactor.js";
+import { isContextOverflow } from "./policy.js";
+export function contextManager(options) {
+    let anchor;
+    return {
+        get anchor() {
+            return anchor;
+        },
+        async compact(canonical, projected, request) {
+            const force = request.reason === "overflow";
+            if (force && (request.error === undefined || !isContextOverflow(request.error)))
+                return undefined;
+            if (!force && request.inputTokens < request.policy.triggerTokens)
+                return undefined;
+            const nodeId = options.nodeId();
+            const attempt = {
+                key: automaticCompactionKey(options.provider.id, options.model, nodeId, canonical.length),
+                scope: `${options.provider.id}\0${options.model}\0${options.identity.conversationId}\0` +
+                    `${request.policy.windowTokens}\0${request.policy.triggerTokens}`,
+                reason: request.reason,
+                inputTokens: request.inputTokens,
+                retryGrowthTokens: Math.max(1_024, Math.min(request.policy.minimumPrefixTokens, request.policy.requestLimitTokens - 256 - request.inputTokens)),
+            };
+            if (!options.gate.allows(attempt))
+                return undefined;
+            let started = false;
+            const result = await compactContext({
+                reason: request.reason,
+                onDiagnostic: options.onDiagnostic,
+                provider: options.provider,
+                model: options.model,
+                effort: options.effort,
+                context: projected,
+                turn: canonical.slice(options.historyStart),
+                nodeId,
+                coveredMessages: anchor?.messageCount ?? 0,
+                lastInputTokens: 0,
+                estimatedInputTokens: request.inputTokens,
+                force,
+                policy: request.policy,
+                signal: options.signal,
+                requestEnvelope: {
+                    system: options.system,
+                    tools: options.tools,
+                    maxOutputTokens: options.maxOutputTokens,
+                },
+                requestIdentity: options.identity,
+                onBegin() {
+                    started = true;
+                    options.onStatus(true);
+                },
+                onEnd() { options.onStatus(false); },
+                onUsage: options.onUsage,
+            });
+            if (result === undefined) {
+                if (started && options.signal?.aborted !== true)
+                    options.gate.failed(attempt);
+                return undefined;
+            }
+            options.gate.succeeded(attempt);
+            anchor = result.anchor;
+            return result.messages;
+        },
+    };
+}

package/dist/context/manual.js

@@ -7,9 +7,8 @@ import { recordAuxiliaryUsage } from "../usage.js";
 import { toolSpecs } from "../tools/index.js";
 import { resolveContextPolicy } from "./capacity.js";
 import { compactContext } from "./compactor.js";
-import { estimateRequestInputTokensResponsive } from "./budget.js";
-import { estimateTokensResponsive, planCompaction } from "./policy.js";
-import { projectToolResultsNewest, toolResultProjectionBudget } from "./request-projection.js";
+import { measureInput, messageCounter } from "./measurement.js";
+import { planCompaction } from "./policy.js";
 import { requestIdentityForSession } from "../request-identity.js";
 const MIN_PREFIX_TOKENS = 512;
 export async function compactSession(session, options = {}) {
@@ -29,9 +28,11 @@ export async function compactSession(session, options = {}) {
         onStatus: (status) => options.onStatus?.(status),
     });
     const specs = toolSpecs(session.tools);
-    const estimatedInputTokens = await estimateRequestInputTokensResponsive({
+    const estimatedInputTokens = await measureInput(session.provider, {
+        model: session.model,
+        effort: session.config.effort,
         system: session.system,
-        messages: projectToolResultsNewest(context, toolResultProjectionBudget(policy)).messages,
+        messages: context,
         tools: specs,
     }, options.signal);
     if (estimatedInputTokens < MIN_PREFIX_TOKENS) {
@@ -41,9 +42,10 @@ export async function compactSession(session, options = {}) {
     const coveredMessages = active.context?.throughNodeId === active.id
         ? active.context.messageCount
         : 0;
-    const plan = await planCompaction(context, active.messages, coveredMessages, session.usage.lastInputTokens, true, policy, estimatedInputTokens, options.signal);
+    const countMessages = await messageCounter(session.provider, session.model, session.config.effort, options.signal);
+    const plan = await planCompaction(context, active.messages, coveredMessages, 0, true, policy, estimatedInputTokens, options.signal, countMessages);
     if (plan === undefined ||
-        await estimateTokensResponsive(plan.prefix, options.signal) < MIN_PREFIX_TOKENS) {
+        await countMessages(plan.prefix, options.signal) < MIN_PREFIX_TOKENS) {
         options.onStatus?.();
         return "unchanged";
     }
@@ -55,7 +57,7 @@ export async function compactSession(session, options = {}) {
         turn: active.messages,
         nodeId: active.id,
         coveredMessages,
-        lastInputTokens: session.usage.lastInputTokens,
+        lastInputTokens: 0,
         estimatedInputTokens,
         precomputedPlan: plan,
         signal: options.signal,
@@ -70,11 +72,10 @@ export async function compactSession(session, options = {}) {
         requestIdentity: requestIdentityForSession(session),
         onBegin: () => options.onStatus?.("Compacting"),
         onEnd: () => options.onStatus?.(),
+        onUsage: (usage) => recordAuxiliaryUsage(session.usage, usage),
     });
     if (result === undefined)
         throw new Error("context could not be compacted");
-    if (result.usage !== undefined)
-        recordAuxiliaryUsage(session.usage, result.usage);
     const next = session.conversation.commit({
         nodeId: active.id,
         parentId: active.parentId,

package/dist/context/measurement.js

@@ -0,0 +1,75 @@
+// Local input estimates anchored only to an unchanged, provider-measured prefix.
+import { createHash } from "node:crypto";
+import { estimateRequestInputTokensResponsive } from "./budget.js";
+/** A response's usage is evidence about that exact request, never later history. */
+export function inputMeter(provider) {
+    let baseline;
+    let epoch = 0;
+    return {
+        async measure(input, signal) {
+            const measuredEpoch = epoch;
+            const estimatedTokens = await measureInput(provider, input, signal);
+            const envelope = fingerprint({
+                provider: provider.id,
+                model: input.model,
+                effort: input.effort,
+                system: input.system,
+                tools: input.tools,
+            });
+            const messages = [];
+            for (const message of input.messages) {
+                signal?.throwIfAborted();
+                // Including raw and usage is deliberately conservative: even a change
+                // to an opaque reserve must invalidate the old provider observation.
+                messages.push(fingerprint(message));
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+            const previous = baseline?.measurement;
+            const anchored = measuredEpoch === epoch && previous !== undefined && previous.envelope === envelope &&
+                previous.messages.length <= messages.length &&
+                previous.messages.every((value, index) => value === messages[index]);
+            const inputTokens = anchored && baseline !== undefined
+                ? baseline.reported + Math.max(0, estimatedTokens - baseline.measurement.estimatedTokens)
+                : estimatedTokens;
+            if (!anchored && measuredEpoch === epoch)
+                baseline = undefined;
+            return Object.freeze({
+                epoch: measuredEpoch,
+                inputTokens,
+                estimatedTokens,
+                source: anchored ? "provider-prefix" : "estimate",
+                envelope,
+                messages: Object.freeze(messages),
+            });
+        },
+        observe(measurement, reported) {
+            if (measurement.epoch !== epoch || reported === undefined || !Number.isSafeInteger(reported) || reported <= 0)
+                return;
+            baseline = { measurement, reported };
+        },
+        reset() {
+            epoch++;
+            baseline = undefined;
+        },
+    };
+}
+export async function measureInput(provider, input, signal) {
+    signal?.throwIfAborted();
+    const tokens = provider.measureInput === undefined
+        ? await estimateRequestInputTokensResponsive(input, signal)
+        : await provider.measureInput(input, signal);
+    signal?.throwIfAborted();
+    if (!Number.isSafeInteger(tokens) || tokens <= 0) {
+        throw new Error("provider returned an invalid input token estimate");
+    }
+    return tokens;
+}
+/** Retention must include opaque replay reserves, excluding the fixed envelope. */
+export async function messageCounter(provider, model, effort, signal) {
+    const input = { model, effort, system: "", messages: [], tools: [] };
+    const overhead = await measureInput(provider, input, signal);
+    return async (messages, currentSignal = signal) => Math.max(1, await measureInput(provider, { ...input, messages: [...messages] }, currentSignal) - overhead);
+}
+function fingerprint(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}

package/dist/context/policy.js

@@ -6,13 +6,13 @@ export const MAX_COMPACTION_PERCENT = 95;
 export const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
 export const REQUEST_ESTIMATE_HEADROOM_PERCENT = 5;
 export const MIN_REQUEST_OUTPUT_TOKENS = 256;
-export async function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy, estimatedInputTokens, signal) {
+export async function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy, estimatedInputTokens, signal, countMessages = estimateTokensResponsive) {
     if (!validPolicy(policy) || coveredMessages < 0 || coveredMessages > turn.length)
         return undefined;
     if (estimatedInputTokens !== undefined &&
         (!Number.isSafeInteger(estimatedInputTokens) || estimatedInputTokens <= 0))
         return undefined;
-    const estimated = estimatedInputTokens ?? await estimateTokensResponsive(context, signal);
+    const estimated = estimatedInputTokens ?? await countMessages(context, signal);
     if (!force &&
         (estimated < policy.targetTokens || Math.max(estimated, lastInputTokens) < policy.triggerTokens))
         return undefined;
@@ -23,13 +23,13 @@ export async function planCompaction(context, turn, coveredMessages, lastInputTo
     if (!await sameMessages(context.slice(contextPrefix), turn.slice(coveredMessages), signal))
         return undefined;
     const targetTokens = force
-        ? Math.min(policy.targetTokens, Math.max(512, Math.floor(estimated / 4)))
+        ? Math.min(policy.targetTokens, Math.max(512, Math.floor(estimated / 2)))
         : policy.targetTokens;
     const recentTokens = Math.min(policy.recentTokens, Math.max(256, Math.floor(targetTokens / 2)));
-    const recent = await recentBoundary(turn, coveredMessages, recentTokens, signal);
+    const recent = await recentBoundary(turn, coveredMessages, recentTokens, signal, countMessages);
     let boundary = recent.boundary;
     let tail = turn.slice(boundary);
-    if (turn.length > 1 && recent.tokens > targetTokens) {
+    if (turn.length > 1 && recent.tokens > policy.requestLimitTokens) {
         boundary = turn.length;
         tail = [];
     }
@@ -37,7 +37,7 @@ export async function planCompaction(context, turn, coveredMessages, lastInputTo
     if (prefixEnd <= 0 || prefixEnd > context.length)
         return undefined;
     const prefix = context.slice(0, prefixEnd);
-    if (!force && await estimateTokensResponsive(prefix, signal) < policy.minimumPrefixTokens) {
+    if (!force && await countMessages(prefix, signal) < policy.minimumPrefixTokens) {
         return undefined;
     }
     return {
@@ -73,10 +73,13 @@ export function policyForContextWindow(context, compactionPercent) {
     });
 }
 export function estimateTokens(messages) {
-    return estimateSerializedTokens(messages) + messages.length * 8;
+    return estimateSerializedTokens(normalized(messages)) + messages.length * 8;
 }
 export async function estimateTokensResponsive(messages, signal) {
-    return await estimateSerializedTokensResponsive(messages, signal) + messages.length * 8;
+    return await estimateSerializedTokensResponsive(normalized(messages), signal) + messages.length * 8;
+}
+function normalized(messages) {
+    return messages.map(({ role, content }) => ({ role, content }));
 }
 export function isContextOverflow(error) {
     const candidate = error;
@@ -85,7 +88,7 @@ export function isContextOverflow(error) {
     const detail = `${candidate.message}\n${candidate.body ?? ""}`;
     return /context_length_exceeded|maximum context length|context window|prompt is too long|input (?:is )?too (?:long|large)|(?:input|prompt|context).{0,80}(?:exceed|maximum|max tokens)/i.test(detail);
 }
-async function recentBoundary(turn, coveredMessages, recentTokens, signal) {
+async function recentBoundary(turn, coveredMessages, recentTokens, signal, countMessages) {
     const minimum = Math.max(coveredMessages, minimumRecentBoundary(turn));
     const candidates = [];
     for (let candidate = coveredMessages; candidate <= minimum; candidate++) {
@@ -96,7 +99,7 @@ async function recentBoundary(turn, coveredMessages, recentTokens, signal) {
     const estimateAt = (candidate) => {
         let estimate = cache.get(candidate);
         if (estimate === undefined) {
-            estimate = estimateTokensResponsive(turn.slice(candidate), signal);
+            estimate = countMessages(turn.slice(candidate), signal);
             cache.set(candidate, estimate);
         }
         return estimate;

package/dist/context/request-observation.js

@@ -0,0 +1,46 @@
+import { publishDiagnostic } from "./diagnostics.js";
+export async function observePreparation(policy, reason, signal, prepare) {
+    const started = performance.now();
+    try {
+        return await prepare();
+    }
+    catch (error) {
+        publishDiagnostic({ kind: "preparation", reason, outcome: signal?.aborted ? "cancelled" : "failed",
+            elapsedMs: Math.round(performance.now() - started), windowTokens: policy.windowTokens,
+            triggerTokens: policy.triggerTokens, requestLimitTokens: policy.requestLimitTokens });
+        throw error;
+    }
+}
+export async function sendObserved(provider, request, measurement, policy, preparationMs, clippedResults) {
+    const started = performance.now();
+    let firstEventMs;
+    let response;
+    let outcome = "failed";
+    try {
+        response = await provider.send({ ...request, onStream(event) {
+                firstEventMs ??= Math.round(performance.now() - started);
+                request.onStream?.(event);
+            } });
+        request.signal?.throwIfAborted();
+        outcome = "completed";
+        return response;
+    }
+    catch (error) {
+        if (request.signal?.aborted)
+            outcome = "cancelled";
+        throw error;
+    }
+    finally {
+        publishDiagnostic({
+            kind: "request", source: measurement.source, outcome,
+            tokenization: provider.inputTokenization?.(request.model) ?? "heuristic",
+            estimatedTokens: measurement.estimatedTokens, inputTokens: measurement.inputTokens,
+            windowTokens: policy.windowTokens, triggerTokens: policy.triggerTokens,
+            requestLimitTokens: policy.requestLimitTokens, outputBudgetTokens: request.maxTokens,
+            preparationMs: Math.round(preparationMs), providerMs: Math.round(performance.now() - started),
+            clippedResults,
+            ...(firstEventMs === undefined ? {} : { firstEventMs }),
+            ...(response?.usage === undefined ? {} : { reportedInputTokens: response.usage.inputTokens }),
+        });
+    }
+}

package/dist/context/request-projection.js

@@ -3,43 +3,17 @@
 import { leadingText, trailingText } from "../text-boundary.js";
 export const TOOL_RESULT_CLIP_MARKER = "[tool output clipped]";
 const FAIR_CONTENT_CODE_UNITS = 256;
-const APPEND_STABLE_RESULT_CODE_UNITS = 16_384;
-const MAX_TOOL_RESULT_PROJECTION_CODE_UNITS = 256_000;
+const MAX_TOOL_RESULT_PROJECTION_CODE_UNITS = 1_000_000;
 export function toolResultProjectionBudget(policy) {
-    return Math.min(MAX_TOOL_RESULT_PROJECTION_CODE_UNITS, policy.targetTokens);
-}
-/**
- * Keep historical result excerpts byte-for-byte stable as new results append.
- * Semantic compaction is allowed to establish a new prefix before the safety
- * fallback below redistributes an exhausted aggregate budget.
- */
-export function projectToolResults(source, requestedCodeUnits) {
-    const results = toolResults(source, requestedCodeUnits);
-    if (results.length === 0) {
-        return { messages: [...source], clippedResults: 0, outputCodeUnits: 0, saturated: false };
-    }
-    const allocations = [];
-    let remaining = requestedCodeUnits;
-    let saturated = false;
-    for (const result of results) {
-        const desired = Math.min(result.output.length, APPEND_STABLE_RESULT_CODE_UNITS);
-        if (desired <= remaining) {
-            allocations.push(desired);
-            remaining -= desired;
-            continue;
-        }
-        saturated = true;
-        const excerpt = remaining >= TOOL_RESULT_CLIP_MARKER.length ? remaining : 0;
-        allocations.push(Math.min(result.output.length, excerpt));
-        remaining -= excerpt;
-    }
-    return projectAllocations(source, allocations, saturated);
+    // Character allocation is only a starting point. The actual provider input
+    // is measured again before it can be sent, including Unicode and framing.
+    return Math.min(MAX_TOOL_RESULT_PROJECTION_CODE_UNITS, policy.targetTokens * 3);
 }
 /** Prefer recent evidence when compaction cannot restore a stable prefix. */
 export function projectToolResultsNewest(source, requestedCodeUnits) {
     const results = toolResults(source, requestedCodeUnits);
     if (results.length === 0) {
-        return { messages: [...source], clippedResults: 0, outputCodeUnits: 0, saturated: false };
+        return { messages: [...source], clippedResults: 0, outputCodeUnits: 0 };
     }
     const allocations = results.map(() => 0);
     let remaining = requestedCodeUnits;
@@ -58,7 +32,7 @@ export function projectToolResultsNewest(source, requestedCodeUnits) {
         allocations[index] = allocations[index] + extra;
         remaining -= extra;
     }
-    return projectAllocations(source, allocations, true);
+    return projectAllocations(source, allocations);
 }
 function toolResults(source, requestedCodeUnits) {
     if (!Number.isSafeInteger(requestedCodeUnits) || requestedCodeUnits < 0) {
@@ -66,7 +40,7 @@ function toolResults(source, requestedCodeUnits) {
     }
     return source.flatMap((message) => message.content.filter((block) => block.kind === "tool_result"));
 }
-function projectAllocations(source, allocations, saturated) {
+function projectAllocations(source, allocations) {
     let resultIndex = 0;
     let clippedResults = 0;
     let outputCodeUnits = 0;
@@ -86,7 +60,7 @@ function projectAllocations(source, allocations, saturated) {
         });
         return changed ? { ...message, content } : message;
     });
-    return { messages, clippedResults, outputCodeUnits, saturated };
+    return { messages, clippedResults, outputCodeUnits };
 }
 function allocateFairExcerpt(results, allocations, available) {
     const needs = results.map((result, index) => {

package/dist/context/request.js

@@ -0,0 +1,22 @@
+// Complete ordinary input; bounded tool projection is an emergency fallback.
+import { MIN_REQUEST_OUTPUT_TOKENS } from "./policy.js";
+import { projectToolResultsNewest, toolResultProjectionBudget } from "./request-projection.js";
+/** Called after optional semantic compaction, immediately before sending. */
+export async function fitRequestInput(input, meter, policy, measurement, signal) {
+    const limit = policy.requestLimitTokens - MIN_REQUEST_OUTPUT_TOKENS;
+    if (measurement.inputTokens <= limit) {
+        return { messages: [...input.messages], measurement, clippedResults: 0 };
+    }
+    let budget = toolResultProjectionBudget(policy);
+    for (;;) {
+        signal?.throwIfAborted();
+        const projection = projectToolResultsNewest(input.messages, budget);
+        const next = await meter.measure({ ...input, messages: projection.messages }, signal);
+        if (next.inputTokens <= limit || budget === 0 || projection.clippedResults === 0) {
+            return { messages: projection.messages, measurement: next, clippedResults: projection.clippedResults };
+        }
+        // At most logarithmically many bounded attempts, then the existing request
+        // guard reports an irreducible prompt/schema instead of a provider call.
+        budget = budget < 256 ? 0 : Math.floor(budget / 2);
+    }
+}

package/dist/context/tokenizer/bpe.js

@@ -0,0 +1,68 @@
+export function countPiece(bytes, ranks) {
+    const text = bytes.toString("latin1");
+    if (ranks.has(text))
+        return 1;
+    const next = Int32Array.from({ length: bytes.length }, (_, i) => i + 1);
+    const previous = Int32Array.from({ length: bytes.length }, (_, i) => i - 1);
+    const heap = [];
+    let count = bytes.length;
+    const offer = (left) => {
+        if (left < 0 || left >= bytes.length)
+            return;
+        const right = next[left];
+        if (right < 0 || right >= bytes.length)
+            return;
+        const end = next[right];
+        const rank = ranks.get(text.slice(left, end));
+        if (rank !== undefined)
+            push(heap, { rank, left, right, end });
+    };
+    for (let i = 0; i + 1 < bytes.length; i++)
+        offer(i);
+    while (heap.length > 0) {
+        const pair = pop(heap);
+        if (next[pair.left] !== pair.right || next[pair.right] !== pair.end)
+            continue;
+        next[pair.left] = pair.end;
+        next[pair.right] = -1;
+        if (pair.end < bytes.length)
+            previous[pair.end] = pair.left;
+        count--;
+        offer(previous[pair.left]);
+        offer(pair.left);
+    }
+    return count;
+}
+function before(a, b) {
+    return a.rank < b.rank || (a.rank === b.rank && a.left < b.left);
+}
+function push(heap, pair) {
+    let index = heap.length;
+    heap.push(pair);
+    while (index > 0) {
+        const parent = (index - 1) >>> 1;
+        if (!before(pair, heap[parent]))
+            break;
+        heap[index] = heap[parent];
+        index = parent;
+    }
+    heap[index] = pair;
+}
+function pop(heap) {
+    const first = heap[0];
+    const tail = heap.pop();
+    if (heap.length === 0)
+        return first;
+    let index = 0;
+    while (index * 2 + 1 < heap.length) {
+        let child = index * 2 + 1;
+        if (child + 1 < heap.length && before(heap[child + 1], heap[child]))
+            child++;
+        if (!before(heap[child], tail))
+            break;
+        heap[index] = heap[child];
+        index = child;
+    }
+    heap[index] = tail;
+    return first;
+}