@qvac/harness 0.8.6 → 0.8.8

package/dist-lib/lib/capabilities/completion.js

@@ -8,14 +8,14 @@ import { AbortedError, raceAbort } from '../helpers/race-abort.js';
 import { raceTimeout } from '../helpers/race-timeout.js';
 import { createRunOutcomeTracker, degenerateAnswer, unnamedWrites, writeReport } from '../helpers/run-outcome.js';
 import { splitThinking } from '../helpers/thinking.js';
-import { clipRawCall, normalizeToolArgs, recoverMarkupToolCalls, recoverPrintedSkillLoad, recoverSkillNamedCall, stripToolCallMarkup, stripToolResponseBlocks, toolCallMarkup } from '../helpers/tool-call-markup.js';
+import { clipRawCall, hasMarkupCall, normalizeToolArgs, recoverMarkupToolCalls, recoverPrintedSkillLoad, recoverSkillNamedCall, stripToolCallMarkup, stripToolResponseBlocks, toolCallMarkup } from '../helpers/tool-call-markup.js';
 import { INTENT_PARAM, INTENT_PARAM_DESCRIPTION, takeToolIntent } from '../helpers/tool-intent.js';
 import { HookPipeline } from '../hooks/pipeline.js';
 import { fallbackToolLabel } from '../helpers/tool-label.js';
 import { hlog } from '../log.js';
 import { resolveLlmGenerationParams } from '../models/llm-presets.js';
 import { toolDialectFor } from '../models/model-catalog.js';
-import { isContextOverflowError, isSdkModelWedgedError } from '../models/sdk-faults.js';
+import { isContextOverflowError, isGrammarOverrunError, isSdkModelWedgedError } from '../models/sdk-faults.js';
 import { annotateLastUserTime, skillsPromptSection, systemPromptParts } from '../prompt.js';
 import { isMetadataMethod } from '../tools/mcp/protocol.js';
 import { unquoteArg } from '../tools/model-args.js';
@@ -25,11 +25,11 @@ import { promptUsageParts, usageBreakdown } from './usage-breakdown.js';
 import { collectToolGrants, enabledTools, isSelected, skillIsActive, skillsAreSelected } from './tool-selection.js';
 import { guardToolCall } from '../tools/outbound-guard.js';
 import { isAvailableState } from '../tools/skills/skill-state-constants.js';
-import { resolveImplicitSkill, resolveSkillMention, skillPreloadMessage } from '../tools/skills/mention.js';
+import { resolveImplicitSkill, resolveSkillMention } from '../tools/skills/mention.js';
 import { NETWORK_TOOLSETS, permittedTools } from '../tools/toolsets.js';
 import { promptPrefixHash } from './prompt-prefix.js';
 import { logToolPrompt } from './tool-prompt-log.js';
-import { DIRECT_CALL_ID, deliversFile, FILE_DELIVERED_NUDGE, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn, withoutSkillLoadTurns } from './tool-turns.js';
+import { DIRECT_CALL_ID, deliversFile, FILE_DELIVERED_NUDGE, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn } from './tool-turns.js';
 export function imageSettingsFrom(agent) {
     if (!agent)
         return undefined;
@@ -60,6 +60,9 @@ const MAX_MUTE_ROUNDS = 1;
 const NARRATED_INTENT = /\b(I['’]ll|I will|Now I|Let me(?! know)|Next,? I)\b[^.!?]*[.!?]?\s*$/i;
 const MAX_WEB_SEARCHES_PER_TURN = 3;
 const MAX_CAPPED_ROUNDS = 1;
+const MAX_CALLS_PER_ROUND = 16;
+const repeatedReadMessage = (name) => `The result of this exact ${name} call is already above. Answer from it now; ` +
+    `do not call ${name} again with the same arguments.`;
 const WEB_SEARCH_LIMIT_MESSAGE = 'Web search limit reached for this question. Answer now from the results already gathered. ' +
     'If something was not found, say so plainly and mention the most relevant sources. ' +
     'Do not call web_search again.';
@@ -101,9 +104,10 @@ export function toSdkTool(tool) {
         parameters: intentParameters(tool, tool.prompt?.parameters ?? tool.parameters)
     };
 }
-function sanitizeTurn(turn) {
+function sanitizeTurn(turn, index, turns) {
     const stripped = stripControlTokens(turn.content);
-    const content = turn.role === 'assistant' ? stripToolCallMarkup(stripped) : stripped;
+    const leaked = turn.role === 'assistant' && turns[index + 1]?.role !== 'tool';
+    const content = leaked ? stripToolCallMarkup(stripped) : stripped;
     return content === turn.content ? turn : { ...turn, content };
 }
 function lastUserContent(messages) {
@@ -139,14 +143,12 @@ function explicitlyDisablesWebSearch(text) {
     return (/\b(?:do\s+not|don't|dont|never)\s+(?:search|browse|look\s+up|find|use)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text) ||
         /\b(?:avoid|without)\s+(?:searching|browsing|using)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text));
 }
-function directToolHistory(history, args, output) {
+function directToolHistory(history, call, output) {
     return [
         ...history,
-        {
-            role: 'assistant',
-            content: toolCallMarkup([{ name: WEB_SEARCH_TOOL_NAME, arguments: args }])
-        },
-        { role: 'tool', content: toolResultTurn(WEB_SEARCH_TOOL_NAME, DIRECT_CALL_ID, output) }
+        { role: 'assistant', content: toolCallMarkup([call]) },
+        { role: 'tool', content: toolResultTurn(call.name, DIRECT_CALL_ID, output) },
+        { role: 'user', content: TOOL_CONTINUATION_NUDGE }
     ];
 }
 function assistantToolTurn(contentText, calls) {
@@ -155,18 +157,6 @@ function assistantToolTurn(contentText, calls) {
     const markup = toolCallMarkup(calls);
     return contentText ? `${contentText}\n\n${markup}` : markup;
 }
-function preloadLastUser(messages, name, body) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const turn = messages[i];
-        if (turn?.role !== 'user') {
-            continue;
-        }
-        const next = [...messages];
-        next[i] = { ...turn, content: skillPreloadMessage(turn.content, name, body) };
-        return next;
-    }
-    return messages;
-}
 function collectStats(state, stats, stopReason) {
     state.stopReason = stopReason;
     if (!stats) {
@@ -218,12 +208,19 @@ function deniedResult() {
 }
 function callKey(name, args) {
     try {
-        return `${name}:${JSON.stringify(args)}`;
+        return `${name}:${JSON.stringify(args, sortedKeys)}`;
     }
     catch {
         return name;
     }
 }
+function sortedKeys(_key, value) {
+    if (!isRecord(value) || Array.isArray(value))
+        return value;
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, value[key]]));
+}
 const RETRYABLE_STATUS = new Set([408, 429]);
 const RETRYABLE_CODE = new Set(['timeout', 'transport', 'busy']);
 function callSucceeded(result, outcome) {
@@ -362,10 +359,11 @@ async function executeCall(tool, args, { ctx, approve, signal, denied, sources =
     return executedCall(output, outcome);
 }
 function runToolContext(scope) {
-    const { agent, attach, fetchAttachment, ragSearch, progress, askUser, signal, runBudget } = scope;
+    const { agent, session, attach, fetchAttachment, ragSearch, progress, askUser, signal, runBudget } = scope;
     const image = imageSettingsFrom(agent);
     return (turnImages = [], ctxSize) => ({
         agentId: agent?.id ?? null,
+        session,
         ctxSize,
         image,
         turnImages: turnImages.length ? turnImages : undefined,
@@ -466,6 +464,20 @@ async function* contentDeltas(events) {
         }
     }
 }
+async function* endAtGrammarOverrun(tokens, state) {
+    try {
+        for await (const token of tokens) {
+            state.rawText += token;
+            yield token;
+        }
+    }
+    catch (err) {
+        if (!isGrammarOverrunError(err)) {
+            throw err;
+        }
+        state.overrun = err;
+    }
+}
 async function* runRoundTokens(result, state, { sdk, signal, startInThink = false }) {
     const cancelThisRound = () => {
         if (result.requestId) {
@@ -473,7 +485,8 @@ async function* runRoundTokens(result, state, { sdk, signal, startInThink = fals
         }
     };
     signal?.addEventListener('abort', cancelThisRound, { once: true });
-    const tokens = stopAtControlToken(contentDeltas(result.events), (token) => {
+    const deltas = endAtGrammarOverrun(contentDeltas(result.events), state);
+    const tokens = stopAtControlToken(deltas, (token) => {
         state.stopToken = token;
     });
     let tokenEvents = 0;
@@ -508,6 +521,9 @@ async function* runRoundTokens(result, state, { sdk, signal, startInThink = fals
         if (contentTail) {
             yield { type: 'content', text: contentTail };
         }
+        if (state.overrun) {
+            throw state.overrun;
+        }
         hlog('stream ended', { events: tokenEvents, stopToken: state.stopToken });
         if (state.stopToken) {
             cancelThisRound();
@@ -533,9 +549,12 @@ function roundTokens(stats) {
     };
     return Object.values(tokens).some((value) => value !== undefined) ? tokens : undefined;
 }
+function acceptedFinal(contentText, fullText = contentText) {
+    return { contentText, toolCalls: [], raw: { fullText } };
+}
 const TRUNCATED_FINAL_MS = 2000;
 function truncatedFinal(final, contentText) {
-    const accepted = { contentText, toolCalls: [], raw: { fullText: contentText } };
+    const accepted = acceptedFinal(contentText);
     const guarded = final.catch((err) => {
         if (isSdkModelWedgedError(err))
             throw err;
@@ -560,7 +579,13 @@ async function* runRecoveredRoundWith(sdk, args, modelId) {
             throw new AbortedError();
         let contentText = '';
         let emitted = false;
-        const state = { stopToken: null, unproven: null, rawContentText: '' };
+        const state = {
+            stopToken: null,
+            unproven: null,
+            rawContentText: '',
+            rawText: '',
+            overrun: null
+        };
         const cacheable = candidate.history === args.history;
         const params = {
             modelId,
@@ -633,6 +658,14 @@ async function* runRecoveredRoundWith(sdk, args, modelId) {
             };
         }
         catch (err) {
+            const recovered = isGrammarOverrunError(err) && hasMarkupCall(state.rawText);
+            let outcome = 'failed';
+            if (recovered) {
+                outcome = 'completed';
+            }
+            else if (isContextOverflowError(err)) {
+                outcome = 'overflowed';
+            }
             if (args.capture) {
                 yield {
                     type: 'inference-sent',
@@ -640,10 +673,21 @@ async function* runRecoveredRoundWith(sdk, args, modelId) {
                     droppedTurns: candidate.droppedTurns,
                     messages: undefined,
                     tokens: undefined,
-                    outcome: isContextOverflowError(err) ? 'overflowed' : 'failed',
+                    outcome,
                     reason: errorMessage(err)
                 };
             }
+            if (recovered) {
+                hlog('grammar overrun recovered', { round: args.round });
+                return {
+                    contentText,
+                    final: acceptedFinal(state.rawContentText, state.rawText),
+                    history: candidate.history,
+                    cacheable,
+                    unproven: state.unproven,
+                    replay: null
+                };
+            }
             if (!isContextOverflowError(err)) {
                 throw err;
             }
@@ -664,7 +708,7 @@ function* reportUnnamedWrites(said, landed) {
         yield { type: 'content', text: unreported };
     }
 }
-export async function* completion(sdk, { modelId, acquireRound, model, agent, ctxSize, cacheKey, thinkingDefault, generationParams: generationParamsOverride, responseFormat, messages: storedMessages, tools: allTools = [], skillCatalog = [], approve, attach, fetchAttachment, ragSearch, progress, askUser, signal, toolConfigs, fsRoots = [], fsWriteRoots = [], captureInferenceCalls = false }) {
+export async function* completion(sdk, { modelId, acquireRound, model, agent, ctxSize, cacheKey, session, thinkingDefault, generationParams: generationParamsOverride, responseFormat, messages: storedMessages, typedText, tools: allTools = [], skillCatalog = [], approve, attach, fetchAttachment, ragSearch, progress, askUser, signal, toolConfigs, fsRoots = [], fsWriteRoots = [], captureInferenceCalls = false }) {
     const pipeline = new HookPipeline();
     const agentId = agent?.id ?? null;
     const disabledToolsets = agent?.sandboxMode
@@ -676,12 +720,12 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         ...fsRoots.filter((root) => root.kind === 'hyper' && root.writable && !fsWriteRoots.includes(root))
     ];
     const messages = storedMessages.map(sanitizeTurn);
+    const userText = typedText === undefined ? lastUserContent(messages) : stripControlTokens(typedText);
     const stats = { tokens: 0, timedTokens: 0, durationMs: 0, ctxSize, backends: [] };
     let runOutcome = 'abandoned';
     let runError;
     const runOutcomes = createRunOutcomeTracker();
     const landed = runOutcomes.confirmedWrites;
-    let preloadCacheKey;
     async function* runTurn() {
         if (signal?.aborted)
             throw new AbortedError();
@@ -692,6 +736,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         };
         const toolContext = runToolContext({
             agent,
+            session: session ?? sessionOf(cacheKey),
             attach,
             fetchAttachment,
             ragSearch,
@@ -704,16 +749,14 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         const toolsSelected = isSelected(agent?.toolsScope, agent?.enabledTools);
         const skillsSelected = skillsAreSelected(agent?.skillsScope, Boolean(agent));
         const inContextSkills = skillCatalog.filter(skillInContext);
-        const mention = resolveSkillMention(lastUserContent(messages), inContextSkills);
         const loadedSkills = loadedSkillsFrom(messages);
         const loadedSkillFiles = loadedSkillFilesFrom(messages);
         const activation = {
             skillsSelected,
-            enabledSkills: agent?.enabledSkills ?? [],
-            mention: mention?.name ?? null,
-            loadedSkills
+            enabledSkills: agent?.enabledSkills ?? []
         };
         const activeSkills = inContextSkills.filter((skill) => skillIsActive(skill.name, activation));
+        const mention = resolveSkillMention(userText, activeSkills);
         const { grantedNames, grantedOwners, grantedOps } = collectToolGrants(activeSkills);
         function selectEnabled() {
             if (responseFormat)
@@ -762,16 +805,15 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             skillIcon = skillEmoji(skillName) ?? skillIcon;
         }
         const toolDialect = model ? toolDialectFor(model) : undefined;
-        let turns = messages;
         let preloadedSkill = null;
-        const preload = mention ?? resolveImplicitSkill(lastUserContent(messages), activeSkills);
+        let preloadedResult = null;
+        const preload = mention ?? resolveImplicitSkill(userText, activeSkills);
         if (preload) {
             const loader = tools.find((tool) => tool.name === SKILL_TOOL_NAME);
             const loaded = loader ? await loader.execute({ name: preload.name }, toolContext()) : null;
             if (loaded && typeof loaded === 'object' && 'content' in loaded) {
                 preloadedSkill = String(loaded.content);
-                const inlined = preloadLastUser(messages, preload.name, preloadedSkill);
-                turns = withoutSkillLoadTurns(inlined, preload.name);
+                preloadedResult = loaded;
                 if (!loadedSkills.has(preload.name)) {
                     const preloadArgs = { name: preload.name };
                     const preloadEffect = 'read';
@@ -799,6 +841,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                         effect: preloadEffect,
                         resource: preloadResource
                     });
+                    preloadedResult = settled.result;
                     yield {
                         type: 'tool-result',
                         name: SKILL_TOOL_NAME,
@@ -841,19 +884,19 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             });
         }
         logSelection();
-        let history = annotateLastUserTime(systemContent ? [{ role: 'system', content: systemContent }, ...turns] : turns);
-        preloadCacheKey = childCacheKey(cacheKey, preloadedSkill, messages.length);
-        let roundCacheKey = preloadedSkill === null ? cacheKey : preloadCacheKey;
+        let history = annotateLastUserTime(systemContent ? [{ role: 'system', content: systemContent }, ...messages] : messages);
+        if (preload && preloadedSkill !== null) {
+            history = directToolHistory(history, { name: SKILL_TOOL_NAME, arguments: { name: preload.name } }, preloadedResult);
+        }
+        let roundCacheKey = cacheKey;
         const runUsage = () => usageBreakdown(promptParts, stats.cacheTokens, model);
         const denied = new Set();
         const failed = new Map();
+        const answered = new Set();
         let blockedRepeats = 0;
         let webSearches = 0;
-        const sources = trustedSourcesFrom(messages);
-        if (preloadedSkill) {
-            sources.push({ origin: 'skill', text: preloadedSkill });
-        }
-        const query = explicitWebSearchQuery(lastUserContent(messages), enabled, {
+        const sources = trustedSourcesFrom(history);
+        const query = explicitWebSearchQuery(userText, enabled, {
             skillPreloaded: preloadedSkill !== null
         });
         const webSearch = enabled.find((tool) => tool.name === WEB_SEARCH_TOOL_NAME);
@@ -908,6 +951,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             if (fold.ok) {
                 webSearches++;
             }
+            if (webSearch.stableRead && execution.executed && callSucceeded(output, executionOutcome)) {
+                answered.add(callKey(webSearch.name, args));
+            }
             if (!activity && !fold.ok) {
                 activity = {
                     type: 'tool-activity',
@@ -926,7 +972,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 name: webSearch.name,
                 result: output
             };
-            history = directToolHistory(history, args, output);
+            history = directToolHistory(history, { name: webSearch.name, arguments: args }, output);
         }
         let outcome = 'exhausted';
         let said = '';
@@ -1030,6 +1076,11 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     break;
                 }
                 hlog('round produced no answer', { round, mute });
+                history = [
+                    ...history,
+                    { role: 'assistant', content: spoken },
+                    { role: 'user', content: TOOL_CONTINUATION_NUDGE }
+                ];
                 if (mute++ < MAX_MUTE_ROUNDS) {
                     continue;
                 }
@@ -1038,6 +1089,10 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             }
             mute = 0;
             narrated = false;
+            if (toolCalls.length > MAX_CALLS_PER_ROUND) {
+                hlog('round over the call cap; the rest are dropped', { round, calls: toolCalls.length });
+                toolCalls = toolCalls.slice(0, MAX_CALLS_PER_ROUND);
+            }
             const resolved = await resolveToolCalls(toolCalls, {
                 enabled,
                 agentId: agent?.id ?? null,
@@ -1063,13 +1118,12 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             for (const { call, tool, args, rawCall, rejection, intent } of resolved) {
                 if (signal?.aborted)
                     throw new AbortedError();
-                const priorFailure = failed.get(callKey(call.name, args));
+                const key = callKey(call.name, args);
+                const priorFailure = failed.get(key);
                 const searchCapped = tool?.name === WEB_SEARCH_TOOL_NAME && webSearches >= MAX_WEB_SEARCHES_PER_TURN;
                 const callCtx = {
                     ...toolContext(turnImages, ctxSize),
-                    skills: [...loadedSkills].filter((name) => !skillsSelected ||
-                        (agent?.enabledSkills ?? []).includes(name) ||
-                        name === mention?.name),
+                    skills: [...loadedSkills].filter((name) => skillIsActive(name, activation)),
                     skillsLoadedThisTurn: [...loadedThisTurn],
                     settings: toolConfigs?.[call.name],
                     toolOps: grantedOps,
@@ -1081,6 +1135,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 };
                 const skillCall = call.name === SKILL_TOOL_NAME;
                 const effect = tool?.effect(args, callCtx) ?? (skillCall ? 'read' : undefined);
+                const stableRead = tool?.stableRead === true && effect === 'read';
+                const priorSuccess = !priorFailure && stableRead && answered.has(key);
                 const resource = tool?.resource?.(args) ?? null;
                 const skillName = unquoteArg(args?.name ?? args?.skill_name ?? args?.skill);
                 const askedFile = skillFileArg(args);
@@ -1089,7 +1145,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     (mainRequested
                         ? loadedThisTurn.has(skillName)
                         : loadedFilesThisTurn.has(fileKey(skillName, unquoteArg(askedFile))));
-                const silent = searchCapped || skillReloaded || priorFailure !== undefined;
+                const silent = searchCapped || skillReloaded || priorFailure !== undefined || priorSuccess;
                 const display = silent
                     ? undefined
                     : labelOf(call.name, args, skillCall ? skillEmoji(skillName) : skillIcon);
@@ -1111,6 +1167,14 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     });
                     execution = terminalCall(priorFailure.result, priorFailure.outcome, { executed: false });
                 }
+                else if (priorSuccess) {
+                    blockedRepeats++;
+                    hlog('repeat of a read that already answered; not run again', {
+                        tool: call.name,
+                        blockedRepeats
+                    });
+                    execution = terminalCall({ content: repeatedReadMessage(call.name) }, { kind: 'success' }, { executed: false });
+                }
                 else if (skillReloaded) {
                     const loadedWhat = mainRequested ? skillName : `${skillName} ${unquoteArg(askedFile)}`;
                     execution = terminalCall({
@@ -1162,18 +1226,27 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 const output = settled.result;
                 const executionOutcome = settled.outcome;
                 if (!priorFailure && settledFailure(output, executionOutcome)) {
-                    failed.set(callKey(call.name, args), settled);
+                    failed.set(key, settled);
                 }
                 else if (execution.executed && callSucceeded(output, executionOutcome)) {
                     progressed = true;
                     answer ??= answerOf(output);
                 }
+                if (execution.executed && !stableRead && !skillCall) {
+                    answered.clear();
+                }
+                else if (stableRead && execution.executed && callSucceeded(output, executionOutcome)) {
+                    answered.add(key);
+                }
                 runOutcomes.record(output, executionOutcome);
                 if (searchCapped) {
                     cappedCalls++;
                     hlog('web_search capped', { searches: webSearches });
                 }
-                else if (tool?.name === WEB_SEARCH_TOOL_NAME && !rejection && !priorFailure) {
+                else if (tool?.name === WEB_SEARCH_TOOL_NAME &&
+                    !rejection &&
+                    !priorFailure &&
+                    !priorSuccess) {
                     webSearches++;
                 }
                 if (call.name === SKILL_TOOL_NAME) {
@@ -1332,16 +1405,11 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             outcome: runOutcome,
             error: runError
         });
-        if (preloadCacheKey) {
-            await sdk.deleteCache?.({ kvCacheKey: preloadCacheKey }).catch(noop);
-        }
     }
 }
-function childCacheKey(cacheKey, preloadedSkill, turnCount) {
-    if (preloadedSkill === null || cacheKey === undefined) {
-        return undefined;
-    }
-    return `${cacheKey}/p${turnCount}`;
+function sessionOf(cacheKey) {
+    const base = cacheKey?.split('/')[0];
+    return base ? base : undefined;
 }
 function toolDecision({ auto, skipAll, approved }) {
     if (auto)

package/dist-lib/lib/capabilities/tool-selection.d.ts

@@ -18,11 +18,9 @@ export declare function collectToolGrants<T extends {
 export interface SkillActivation {
     skillsSelected: boolean;
     enabledSkills: ReadonlyArray<string>;
-    mention: string | null;
-    loadedSkills: ReadonlySet<string>;
 }
 export declare function skillsAreSelected(scope: 'all' | 'selected' | null | undefined, hasAgent: boolean): boolean;
-export declare function skillIsActive(name: string, { skillsSelected, enabledSkills, mention, loadedSkills }: SkillActivation): boolean;
+export declare function skillIsActive(name: string, { skillsSelected, enabledSkills }: SkillActivation): boolean;
 export interface SelectableTool {
     name: string;
     skillGated?: boolean | undefined;

package/dist-lib/lib/capabilities/tool-selection.js

@@ -25,10 +25,8 @@ export function collectToolGrants(skills) {
 export function skillsAreSelected(scope, hasAgent) {
     return hasAgent && scope !== 'all';
 }
-export function skillIsActive(name, { skillsSelected, enabledSkills, mention, loadedSkills }) {
-    if (!skillsSelected)
-        return true;
-    return enabledSkills.includes(name) || name === mention || loadedSkills.has(name);
+export function skillIsActive(name, { skillsSelected, enabledSkills }) {
+    return !skillsSelected || enabledSkills.includes(name);
 }
 export function isSelected(scope, list) {
     return (scope ?? (list?.length ? 'selected' : 'all')) === 'selected';

package/dist-lib/lib/capabilities/tool-turns.d.ts

@@ -9,4 +9,3 @@ export declare function skillLoadedTurn(name: string): string;
 export declare function attachmentTurn(name: string, result: unknown): string | null;
 export declare function loadedSkillsFrom(messages: readonly Message[]): Set<string>;
 export declare function loadedSkillFilesFrom(messages: readonly Message[]): Map<string, Set<string>>;
-export declare function withoutSkillLoadTurns(messages: readonly Message[], name: string): Message[];

package/dist-lib/lib/capabilities/tool-turns.js

@@ -71,12 +71,6 @@ export function loadedSkillFilesFrom(messages) {
     }
     return loaded;
 }
-export function withoutSkillLoadTurns(messages, name) {
-    return messages.filter((turn) => {
-        const payload = skillLoadPayload(turn);
-        return !payload || payload.name !== name || payload.file !== undefined;
-    });
-}
 function* skillLoadPayloads(messages) {
     for (const turn of messages) {
         const payload = skillLoadPayload(turn);

package/dist-lib/lib/connect.js

@@ -102,6 +102,7 @@ export class RemoteHarness extends EventEmitter {
             model: context.model,
             agent: knobs(context.agent),
             cacheKey: context.cacheKey,
+            session: context.session,
             thinkingDefault: context.thinkingDefault,
             generationParams: context.generationParams,
             responseFormat: context.responseFormat,
@@ -111,6 +112,7 @@ export class RemoteHarness extends EventEmitter {
                 content,
                 attachments: attachments?.map(({ path: file }) => ({ path: file }))
             })),
+            payload: { typedText: context.typedText },
             toolConfigs: context.toolConfigs,
             grantedDirs: context.grantedDirs,
             grantedDrives: context.grantedDrives,
@@ -509,6 +511,7 @@ export class RemoteHarness extends EventEmitter {
             }));
             return {
                 name: skill.name,
+                displayName: skill.displayName || undefined,
                 description: skill.description,
                 tools: skill.tools ?? [],
                 credentials: skill.credentials ?? [],

package/dist-lib/lib/contract-types.d.ts

@@ -46,7 +46,9 @@ export interface CompletionContext {
     model: string;
     agent: AgentKnobs;
     messages: ChatMessage[];
+    typedText?: string;
     cacheKey?: string;
+    session?: string;
     thinkingDefault?: string;
     toolConfigs?: Record<string, Record<string, unknown>>;
     generationParams?: LlmGenerationParams;

package/dist-lib/lib/helpers/tool-call-markup.d.ts

@@ -9,6 +9,7 @@ export declare function clipRawCall(raw: string): string;
 export interface KnownTool {
     readonly name: string;
 }
+export declare function hasMarkupCall(text: string): boolean;
 export declare function recoverMarkupToolCalls(text: string, knownTools: ReadonlyArray<KnownTool>): RecoveredToolCall[];
 export declare function stripToolCallMarkup(text: string): string;
 export declare function stripToolResponseBlocks(text: string): string;

package/dist-lib/lib/helpers/tool-call-markup.js

@@ -46,6 +46,9 @@ export const MAX_RAW_CALL_CHARS = 4096;
 export function clipRawCall(raw) {
     return raw.length > MAX_RAW_CALL_CHARS ? raw.slice(0, MAX_RAW_CALL_CHARS) : raw;
 }
+export function hasMarkupCall(text) {
+    return !markupBlocks(text, FUNCTION_OPEN, FUNCTION_CLOSE).next().done;
+}
 export function recoverMarkupToolCalls(text, knownTools) {
     const known = new Set(knownTools.map((tool) => tool.name));
     const calls = [];

package/dist-lib/lib/models/context-choice.d.ts

@@ -0,0 +1,15 @@
+import type { CapabilityProfile } from './model-catalog-constants.ts';
+export interface ContextAsk {
+    trained(): Promise<number | undefined>;
+    fits(ctxSize: number): Promise<boolean>;
+}
+export declare class ContextChoice {
+    private readonly _profile;
+    private readonly _pending;
+    private readonly _chosen;
+    constructor(profile: () => Promise<CapabilityProfile | undefined>);
+    static ceiling(profile: CapabilityProfile | undefined): number | undefined;
+    chosen(key: string): number | undefined;
+    choose(key: string, tier: number, ask: ContextAsk): Promise<number>;
+    private _climb;
+}

package/dist-lib/lib/models/context-choice.js

@@ -0,0 +1,55 @@
+const RUNGS = [262_144, 131_072, 65_536];
+const CEILINGS = {
+    mid: 65_536,
+    high: 131_072,
+    xhigh: 262_144
+};
+export class ContextChoice {
+    _profile;
+    _pending = new Map();
+    _chosen = new Map();
+    constructor(profile) {
+        this._profile = profile;
+    }
+    static ceiling(profile) {
+        return profile && CEILINGS[profile];
+    }
+    chosen(key) {
+        return this._chosen.get(key);
+    }
+    choose(key, tier, ask) {
+        const pending = this._pending.get(key);
+        if (pending) {
+            return pending;
+        }
+        const choice = this._climb(tier, ask).then((ctxSize) => {
+            if (ctxSize === undefined) {
+                this._pending.delete(key);
+                return tier;
+            }
+            this._chosen.set(key, ctxSize);
+            return ctxSize;
+        });
+        this._pending.set(key, choice);
+        return choice;
+    }
+    async _climb(tier, ask) {
+        const ceiling = ContextChoice.ceiling(await this._profile());
+        if (!ceiling || ceiling <= tier) {
+            return tier;
+        }
+        const trained = await ask.trained();
+        if (!trained) {
+            return undefined;
+        }
+        for (const rung of RUNGS) {
+            if (rung > ceiling || rung > trained || rung <= tier) {
+                continue;
+            }
+            if (await ask.fits(rung)) {
+                return rung;
+            }
+        }
+        return tier;
+    }
+}