@qvac/harness 0.8.5 → 0.8.7

package/dist-lib/lib/audio-transcode-bare.d.ts

@@ -1,2 +1,2 @@
+export declare function decodeToPcm16kMono(input: Uint8Array): AsyncGenerator<Uint8Array>;
 export declare function transcodeToWav16kMono(input: Uint8Array): Promise<Uint8Array | null>;
-export declare function transcodeToPcm16kMono(input: Uint8Array): Promise<Uint8Array | null>;

package/dist-lib/lib/audio-transcode-bare.js

@@ -92,13 +92,12 @@ const YIELD_EVERY_PACKETS = 32;
 function yieldToLoop() {
     return new Promise((resolve) => setTimeout(resolve, 0));
 }
-async function decodeToPcmChunks(inputFormat, { stream, decoder, rate }) {
-    const chunks = [];
+async function* decodeToPcmChunks(inputFormat, { stream, decoder, rate }) {
     const packet = new ffmpeg.Packet();
     const flush = new ffmpeg.Packet();
     const frame = new ffmpeg.Frame();
     const samples = new ffmpeg.Samples();
-    const target = { frame, samples, chunks, rate };
+    const target = { frame, samples, chunks: [], rate };
     let resampler = null;
     let packets = 0;
     try {
@@ -107,13 +106,15 @@ async function decodeToPcmChunks(inputFormat, { stream, decoder, rate }) {
                 resampler = drainDecodedFrames(decoder, resampler, target);
             }
             packet.unref();
+            yield* target.chunks.splice(0);
             if (++packets % YIELD_EVERY_PACKETS === 0) {
                 await yieldToLoop();
             }
         }
         decoder.sendPacket(flush);
         resampler = drainDecodedFrames(decoder, resampler, target);
-        chunks.push(...flushResampler(resampler, samples, rate));
+        yield* target.chunks.splice(0);
+        yield* flushResampler(resampler, samples, rate);
     }
     finally {
         resampler?.destroy();
@@ -121,35 +122,31 @@ async function decodeToPcmChunks(inputFormat, { stream, decoder, rate }) {
         flush.destroy();
         packet.destroy();
     }
-    return chunks;
 }
-async function decodeInputToPcm(input, rate) {
-    let inputFormat = null;
+export async function* decodeToPcm16kMono(input) {
+    const inputFormat = new ffmpeg.InputFormatContext(bufferReadIO(input));
     let decoder = null;
     try {
-        const format = new ffmpeg.InputFormatContext(bufferReadIO(input));
-        inputFormat = format;
-        const stream = format.getBestStream(ffmpeg.constants.mediaTypes.AUDIO);
+        const stream = inputFormat.getBestStream(ffmpeg.constants.mediaTypes.AUDIO);
         decoder = stream.decoder();
         decoder.open();
-        const chunks = await decodeToPcmChunks(format, { stream, decoder, rate });
-        return chunks.length === 0 ? null : b4a.concat(chunks);
-    }
-    catch (e) {
-        hlog('audio decode/resample failed', { error: errorMessage(e) });
-        return null;
+        yield* decodeToPcmChunks(inputFormat, { stream, decoder, rate: TARGET_SAMPLE_RATE });
     }
     finally {
-        if (decoder) {
-            decoder.destroy();
-        }
-        inputFormat?.destroy();
+        decoder?.destroy();
+        inputFormat.destroy();
     }
 }
 export async function transcodeToWav16kMono(input) {
-    const pcm = await decodeInputToPcm(input, TARGET_SAMPLE_RATE);
-    return pcm ? buildWavBuffer(pcm) : null;
-}
-export async function transcodeToPcm16kMono(input) {
-    return decodeInputToPcm(input, TARGET_SAMPLE_RATE);
+    const chunks = [];
+    try {
+        for await (const chunk of decodeToPcm16kMono(input)) {
+            chunks.push(chunk);
+        }
+    }
+    catch (e) {
+        hlog('audio decode/resample failed', { error: errorMessage(e) });
+        return null;
+    }
+    return chunks.length === 0 ? null : buildWavBuffer(b4a.concat(chunks));
 }

package/dist-lib/lib/audio-transcode-node.d.ts

@@ -1,2 +1,2 @@
 export declare function transcodeToWav16kMono(_input: Uint8Array): Promise<Uint8Array | null>;
-export declare function transcodeToPcm16kMono(_input: Uint8Array): Promise<Uint8Array | null>;
+export declare function decodeToPcm16kMono(_input: Uint8Array): AsyncGenerator<Uint8Array>;

package/dist-lib/lib/audio-transcode-node.js

@@ -1,6 +1,4 @@
 export async function transcodeToWav16kMono(_input) {
     return null;
 }
-export async function transcodeToPcm16kMono(_input) {
-    return null;
-}
+export async function* decodeToPcm16kMono(_input) { }

package/dist-lib/lib/capabilities/audio-resample.d.ts

@@ -11,5 +11,5 @@ export interface ResampledAudio {
     readonly transcoded: boolean;
 }
 export declare function resampleForTranscription(bytes: Uint8Array): Promise<ResampledAudio>;
-export declare function pcmForTranscription(bytes: Uint8Array): Promise<Uint8Array | null>;
+export declare function pcmForTranscription(bytes: Uint8Array): AsyncGenerator<Uint8Array>;
 export {};

package/dist-lib/lib/capabilities/audio-resample.js

@@ -1,5 +1,5 @@
 import b4a from 'b4a';
-import { transcodeToPcm16kMono, transcodeToWav16kMono } from '#audio-transcode';
+import { decodeToPcm16kMono, transcodeToWav16kMono } from '#audio-transcode';
 const TARGET_SAMPLE_RATE = 16000;
 const TARGET_CHANNELS = 1;
 const TARGET_BITS_PER_SAMPLE = 16;
@@ -73,12 +73,11 @@ function wavPcmData(bytes) {
     }
     return null;
 }
-export async function pcmForTranscription(bytes) {
-    if (wavFormat(bytes) && !needsResample(bytes)) {
-        const pcm = wavPcmData(bytes);
-        if (pcm) {
-            return pcm;
-        }
+export async function* pcmForTranscription(bytes) {
+    const pcm = wavFormat(bytes) && !needsResample(bytes) ? wavPcmData(bytes) : null;
+    if (pcm) {
+        yield pcm;
+        return;
     }
-    return transcodeToPcm16kMono(bytes);
+    yield* decodeToPcm16kMono(bytes);
 }

package/dist-lib/lib/capabilities/completion.d.ts

@@ -1,4 +1,4 @@
-import type { CompletionFinal, Tool as SdkTool, ToolDialect } from '@qvac/sdk';
+import type { CompletionEvent as SdkCompletionEvent, CompletionFinal, Tool as SdkTool, ToolDialect } from '@qvac/sdk';
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import { type TextEvent } from '../helpers/thinking.ts';
 import type { ToolCallDisplay } from '../tool-call-display.ts';
@@ -125,6 +125,7 @@ export interface ToolExecuteContext {
     skills?: readonly string[] | undefined;
     skillsLoadedThisTurn?: readonly string[] | undefined;
     ctxSize?: number | undefined;
+    session?: string | undefined;
     image?: ImageSettings | undefined;
     settings?: Record<string, unknown> | undefined;
     turnImages?: {
@@ -266,7 +267,7 @@ export interface InferenceTokens {
 export type CompletionEvent = TextEvent | ToolCallEvent | ToolResultEvent | ToolActivityEvent | ErrorEvent | AbortedEvent | MetricsEvent | InferenceCallEvent | InferenceSentEvent;
 export interface CompletionSdkResult {
     requestId?: string;
-    tokenStream: AsyncIterable<string>;
+    events: AsyncIterable<SdkCompletionEvent>;
     final: Promise<CompletionFinal>;
 }
 export type ResponseFormat = {
@@ -308,10 +309,12 @@ interface CompletionArgs {
     agent?: Agent;
     ctxSize?: number;
     cacheKey?: string;
+    session?: string;
     thinkingDefault?: string;
     generationParams?: LlmGenerationParams;
     responseFormat?: ResponseFormat;
     messages: Message[];
+    typedText?: string;
     tools?: ToolDefinition[];
     skillCatalog?: readonly CompletionSkillEntry[];
     approve?: ApproveFn;
@@ -332,5 +335,5 @@ export declare function toSdkTool(tool: ToolDefinition): SdkTool;
 export type CompletionSkillEntry = SkillCatalogEntry & {
     readonly status?: SkillState;
 };
-export declare function completion(sdk: CompletionSdk, { 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 }: CompletionArgs): AsyncGenerator<CompletionEvent>;
+export declare function completion(sdk: CompletionSdk, { 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 }: CompletionArgs): AsyncGenerator<CompletionEvent>;
 export {};

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 { customToolDialect } from '../models/model-catalog.js';
-import { isContextOverflowError, isSdkModelWedgedError } from '../models/sdk-faults.js';
+import { toolDialectFor } from '../models/model-catalog.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;
@@ -139,14 +139,11 @@ 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) }
     ];
 }
 function assistantToolTurn(contentText, calls) {
@@ -155,18 +152,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) {
@@ -362,10 +347,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,
@@ -459,6 +445,27 @@ function unprovenReplay(state, final) {
     }
     return state.unproven;
 }
+async function* contentDeltas(events) {
+    for await (const event of events) {
+        if (event.type === 'contentDelta') {
+            yield event.text;
+        }
+    }
+}
+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) {
@@ -466,7 +473,8 @@ async function* runRoundTokens(result, state, { sdk, signal, startInThink = fals
         }
     };
     signal?.addEventListener('abort', cancelThisRound, { once: true });
-    const tokens = stopAtControlToken(result.tokenStream, (token) => {
+    const deltas = endAtGrammarOverrun(contentDeltas(result.events), state);
+    const tokens = stopAtControlToken(deltas, (token) => {
         state.stopToken = token;
     });
     let tokenEvents = 0;
@@ -501,6 +509,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();
@@ -526,9 +537,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;
@@ -553,7 +567,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,
@@ -626,6 +646,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',
@@ -633,10 +661,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;
             }
@@ -657,7 +696,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
@@ -669,6 +708,7 @@ 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;
@@ -684,6 +724,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         };
         const toolContext = runToolContext({
             agent,
+            session: session ?? sessionOf(cacheKey),
             attach,
             fetchAttachment,
             ragSearch,
@@ -696,16 +737,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)
@@ -753,17 +792,16 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             }
             skillIcon = skillEmoji(skillName) ?? skillIcon;
         }
-        const toolDialect = model ? customToolDialect(model) : undefined;
-        let turns = messages;
+        const toolDialect = model ? toolDialectFor(model) : undefined;
         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';
@@ -791,6 +829,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,
@@ -833,18 +872,19 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             });
         }
         logSelection();
-        let history = annotateLastUserTime(systemContent ? [{ role: 'system', content: systemContent }, ...turns] : turns);
-        let roundCacheKey = preloadedSkill === null ? cacheKey : undefined;
+        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);
+            history.push({ role: 'user', content: TOOL_CONTINUATION_NUDGE });
+        }
+        let roundCacheKey = cacheKey;
         const runUsage = () => usageBreakdown(promptParts, stats.cacheTokens, model);
         const denied = new Set();
         const failed = new Map();
         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);
@@ -917,7 +957,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 = '';
@@ -1021,6 +1061,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;
                 }
@@ -1058,9 +1103,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 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,
@@ -1325,6 +1368,10 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         });
     }
 }
+function sessionOf(cacheKey) {
+    const base = cacheKey?.split('/')[0];
+    return base ? base : undefined;
+}
 function toolDecision({ auto, skipAll, approved }) {
     if (auto)
         return 'auto';

package/dist-lib/lib/capabilities/download.d.ts

@@ -45,4 +45,6 @@ export type SdkOrLoader = DownloadSdk | (() => Promise<DownloadSdk>);
 export interface DownloadEventStream extends Readable {
     [Symbol.asyncIterator](): AsyncIterableIterator<DownloadEvent>;
 }
-export declare function download(sdkOrLoader: SdkOrLoader, args: DownloadArgs, onSettled?: () => void): DownloadEventStream;
+type TerminalEvent = Exclude<DownloadEvent, DownloadProgressEvent>;
+export declare function download(sdkOrLoader: SdkOrLoader, args: DownloadArgs, onSettled?: (event: TerminalEvent) => void): DownloadEventStream;
+export {};

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

@@ -17,7 +17,7 @@ export function download(sdkOrLoader, args, onSettled) {
         settled = true;
         stream.push(event);
         stream.push(null);
-        onSettled?.();
+        onSettled?.(event);
     };
     const cancelOp = () => {
         if (cancelSent || opDone || !requestId || !sdkRef?.cancel)

package/dist-lib/lib/capabilities/preview-model-source.d.ts

@@ -41,6 +41,7 @@ export type PreviewFetch = (url: string, init?: {
     redirect?: 'follow';
 }) => Promise<PreviewResponse>;
 export interface FitQuery {
+    src: string;
     sha256Checksum: string;
     name: string;
     contextTokens: number;

package/dist-lib/lib/capabilities/preview-model-source.js

@@ -365,6 +365,7 @@ async function assess({ file, header }, taskType, deps) {
     }
     try {
         return await deps.assessFit({
+            src: file.src,
             sha256Checksum: file.sha256,
             name: header.name ?? file.label,
             contextTokens: defaultContextSize(file.src, header.contextLength)

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/capabilities/usage-breakdown.js

@@ -1,8 +1,11 @@
+import { toolDialectFor } from '../models/model-catalog.js';
 import { detectToolDialect } from '../models/tool-dialect.js';
 const QWEN35 = { prose: 4.38, schema: 4.08, toolBlockTokens: 189 };
 const DENSITY_BY_DIALECT = new Map([['qwen35', QWEN35]]);
 export function densityFor(modelName) {
-    const dialect = modelName ? detectToolDialect(modelName, modelName) : undefined;
+    const dialect = modelName
+        ? (toolDialectFor(modelName) ?? detectToolDialect(modelName, modelName))
+        : undefined;
     return (dialect && DENSITY_BY_DIALECT.get(dialect)) ?? QWEN35;
 }
 export function promptUsageParts({ system, toolSchemas }) {

package/dist-lib/lib/capabilities/voice.d.ts

@@ -75,7 +75,11 @@ export interface TranscribeStreamingOptions {
     modelId: string;
     signal?: BareAbortSignal | undefined;
 }
-export declare function transcribeStreaming(sdk: VoiceSdk, pcm: Uint8Array, { modelId, signal }: TranscribeStreamingOptions): Promise<string>;
+export interface TranscribeAudioOptions extends TranscribeStreamingOptions {
+    audio: Buffer;
+}
+export declare function transcribeAudio(sdk: VoiceSdk, pcm: AsyncIterable<Uint8Array>, { modelId, signal, audio }: TranscribeAudioOptions): Promise<string>;
+export declare function transcribeStreaming(sdk: VoiceSdk, pcm: AsyncIterable<Uint8Array>, opts: TranscribeStreamingOptions): Promise<string>;
 export declare function speakStreamOnce(sdk: VoiceSdk, modelId: string, text: AsyncIterable<string>): AsyncGenerator<SpeakResult>;
 export declare function speakable(text: string): string;
 export declare function speakOnce(sdk: VoiceSdk, modelId: string, text: string): Promise<number[]>;