@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

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

@@ -1,10 +1,97 @@
 import { isRecord } from '../guards.js';
-import { SKILL_TOOL_NAME } from './tool-names.js';
-import { isFailureResultReference, readFailureResult } from '../machine/index.js';
+import { Agent } from '../agent/index.js';
+import { headTail } from '../helpers/head-tail.js';
+import { compactContent } from '../context-window.js';
+import { TOOL_SEARCH_TOOL_NAME } from './sdk-tool.js';
+import { isFailureResultReference, readFailureResult } from '../helpers/failure-result.js';
 export const DIRECT_CALL_ID = 'call-direct';
-export { TOOL_CONTINUATION_NUDGE } from '../machine/index.js';
+export const MAX_TOOL_ROUNDS = 10;
+export const GOAL_ROUNDS = 40;
+export const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export const FILE_DELIVERED_NUDGE = '[Tool results above. The file is attached to the chat and shown to the user. Answer now, unless the request still needs a file that is not made yet.]';
+export const TOOL_DENIED_MESSAGE = 'The user declined this call. Do not retry it or call it with different arguments to get ' +
+    'around the refusal. Tell the user plainly what you could not do, and never present a ' +
+    'result you did not obtain.';
+export const TOOL_CUT_OFF_MESSAGE = 'This tool call was not executed: the response hit the output token limit, so its ' +
+    'arguments may be truncated. Re-issue the tool call with complete arguments, and keep ' +
+    'them short enough to finish.';
+export const GOAL_CONTINUATION_NUDGE = '[The goal is not met yet. Keep working on it: call the next tool. Track the work with ' +
+    'update_plan and mark each step done as you finish it; the goal is met when every step is done.]';
+export function checkMaxToolRounds(rounds) {
+    if (!Number.isSafeInteger(rounds) || rounds < 1) {
+        throw new Error(`maxToolRounds must be an integer of 1 or more, got ${rounds}`);
+    }
+    return rounds;
+}
+export function checkGoal(goal, responseFormat) {
+    if (responseFormat) {
+        throw new Error('A goal cannot run with a responseFormat: the run would have no plan to finish');
+    }
+    if (typeof goal.objective !== 'string' || !goal.objective.trim()) {
+        throw new Error('A goal needs an objective');
+    }
+    for (const key of ['rounds', 'ms', 'tokens']) {
+        const value = goal[key];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {
+            throw new Error(`goal.${key} must be an integer of 1 or more, got ${value}`);
+        }
+    }
+    return goal;
+}
+export const TOOL_RESULT_MAX_CHARS = 65_536;
+const MIN_LEAF_CHARS = 256;
+const HOOK_CONTEXT_KEY = 'hookContext';
+export function withHookContext(output, context) {
+    if (context === undefined) {
+        return output;
+    }
+    const base = isRecord(output) && !Array.isArray(output) ? output : { result: output };
+    const prior = base[HOOK_CONTEXT_KEY];
+    return {
+        ...base,
+        [HOOK_CONTEXT_KEY]: typeof prior === 'string' ? `${prior}\n${context}` : context
+    };
+}
+export function deliversFile(output) {
+    return isRecord(output) && Array.isArray(output.attachments) && output.attachments.length > 0;
+}
 export function toolResultTurn(name, id, output) {
-    return `[Tool: ${name} (${id})]\n${JSON.stringify(historyPayload(output))}`;
+    let context = '';
+    let shown = output;
+    if (isRecord(output) && typeof output[HOOK_CONTEXT_KEY] === 'string') {
+        const { [HOOK_CONTEXT_KEY]: added, ...rest } = output;
+        context = `\n${String(added)}`;
+        shown = rest;
+    }
+    const payload = historyPayload(shown);
+    if (name === TOOL_SEARCH_TOOL_NAME) {
+        return JSON.stringify(payload);
+    }
+    const text = name === Agent.SKILL_TOOL_NAME ? JSON.stringify(payload) : fitted(payload);
+    return `[Tool: ${name} (${id})]\n${text}${context}`;
+}
+function fitted(payload) {
+    const whole = JSON.stringify(payload);
+    if (whole === undefined || whole.length <= TOOL_RESULT_MAX_CHARS) {
+        return whole;
+    }
+    const render = (cap) => JSON.stringify(payload, (_key, value) => typeof value === 'string' && value.length > cap ? headTail(value, cap) : value);
+    const floor = render(MIN_LEAF_CHARS);
+    if (floor.length > TOOL_RESULT_MAX_CHARS) {
+        return floor;
+    }
+    let fits = MIN_LEAF_CHARS;
+    let over = whole.length;
+    while (over - fits > 1) {
+        const mid = Math.floor((fits + over) / 2);
+        if (render(mid).length <= TOOL_RESULT_MAX_CHARS) {
+            fits = mid;
+        }
+        else {
+            over = mid;
+        }
+    }
+    return render(fits);
 }
 export function toolResultHistoryEntry({ name, id, output, resultRef }) {
     return resultRef
@@ -24,18 +111,41 @@ export function materializeCompletionHistory(history, values) {
         if (!stored) {
             throw new Error(`History references missing failed tool result: ${entry.ref}`);
         }
+        const content = toolResultTurn(stored.name, entry.callId, readFailureResult(stored.result));
         return {
             role: 'tool',
-            content: toolResultTurn(stored.name, entry.callId, readFailureResult(stored.result))
+            content: entry.compactedTo === undefined ? content : compactContent(content, entry.compactedTo)
         };
     });
 }
-export function skillLoadedTurn(name) {
-    return toolResultTurn(SKILL_TOOL_NAME, DIRECT_CALL_ID, {
+export function redactFailureTurns(history, failures, redact) {
+    const out = [...history];
+    for (const { at, name, callId, result, compactedTo } of redact(failures)) {
+        const content = toolResultTurn(name, callId, readFailureResult(result));
+        out[at] = {
+            role: 'tool',
+            content: compactedTo === undefined ? content : compactContent(content, compactedTo)
+        };
+    }
+    return out;
+}
+export function skillLoadedTurn(name, id = DIRECT_CALL_ID) {
+    return toolResultTurn(Agent.SKILL_TOOL_NAME, id, {
         name,
         content: `${name} was loaded in an earlier turn but its instructions are not in this context. Call the skill tool with this name again before doing its work.`
     });
 }
+const PRELOAD_HEAD = '[Skill invoked by user: ';
+const PRELOAD_USER = "\n\nThe user's message:\n";
+export function skillPreloadMessage(content, name, body) {
+    return `${PRELOAD_HEAD}${name}]\n${body}${PRELOAD_USER}${content}`;
+}
+export function splitPreloadMessage(text) {
+    const at = text.lastIndexOf(PRELOAD_USER);
+    return text.startsWith(PRELOAD_HEAD) && at >= 0
+        ? { skill: text.slice(0, at), user: text.slice(at + PRELOAD_USER.length) }
+        : null;
+}
 function refFrom(value) {
     if (!value || typeof value !== 'object') {
         return null;
@@ -110,11 +220,11 @@ function skillLoadPayload(turn) {
     if (turn.role !== 'tool')
         return null;
     const text = String(turn.content ?? '');
-    if (!text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`)) {
+    if (!text.startsWith(`[Tool: ${Agent.SKILL_TOOL_NAME} (`)) {
         return null;
     }
     try {
-        const payload = JSON.parse(text.slice(text.indexOf('\n') + 1));
+        const payload = JSON.parse(text.split('\n', 2)[1] ?? '');
         if (typeof payload !== 'object' || payload === null) {
             return null;
         }
@@ -130,7 +240,7 @@ function skillLoadPayload(turn) {
     }
 }
 const HOST_ONLY_KEYS = ['data', 'hostNotice'];
-function historyPayload(output) {
+export function historyPayload(output) {
     if (!output || typeof output !== 'object')
         return output;
     if (!HOST_ONLY_KEYS.some((key) => key in output))

package/dist-lib/lib/capabilities/usage-breakdown.d.ts

@@ -1,4 +1,4 @@
-import type { SystemPromptParts } from '../prompt.ts';
+import type { SystemPromptParts } from '../contract/index.ts';
 export interface PromptDensity {
     prose: number;
     schema: number;

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/connect.d.ts

@@ -4,6 +4,7 @@ import { type KvCacheDeletionResult } from './capabilities/kv-cache.ts';
 import type { CustomModelEntry } from './models/model-catalog.ts';
 import { type ModelSourcePreview, type PreviewModelSourceContext } from './capabilities/preview-model-source.ts';
 import type { CapabilityInfo, CompletionContext, CredentialEntry, DetectedLanguage, DetectLanguageContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, InfraModel, InvokeContext, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SkillsOptions, SkillWriteResult, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, LoadModelContext, LoadModelResult, UnloadModelContext, UnloadModelResult, WarmModelContext } from './contract-types.ts';
+import type { KnowledgeArtifact, KnowledgeHit, KnowledgeQuery, KnowledgeRemoved, KnowledgeStatus, KnowledgeUpsertResult } from './contract/knowledge.ts';
 import { type EmbedDevice } from './models/embed-config.ts';
 import type { DeleteModelSummary } from './models/model-delete.ts';
 import type { CopyBaseResult, DeleteOverlayResult, ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud.ts';
@@ -30,6 +31,7 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     private _ensure;
     private _open;
     completion(context: CompletionContext | import('./contract-types.ts').ResumeCompletionContext): AsyncIterable<HarnessEvent>;
+    private _hop;
     invoke(context: InvokeContext): AsyncIterable<HarnessEvent>;
     private _run;
     download(context: DownloadContext): AsyncIterable<HarnessEvent>;
@@ -55,6 +57,10 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     warmModel(context: WarmModelContext): Promise<void>;
     loadModel(context: LoadModelContext): Promise<LoadModelResult>;
     unloadModel(context: UnloadModelContext): Promise<UnloadModelResult>;
+    knowledgeUpsert(artifact: KnowledgeArtifact): Promise<KnowledgeUpsertResult>;
+    knowledgeRemove(artifactId: string): Promise<KnowledgeRemoved>;
+    knowledgeSearch(query: Omit<KnowledgeQuery, 'signal'>): Promise<KnowledgeHit[]>;
+    knowledgeStatus(): Promise<KnowledgeStatus>;
     list(options?: ListModelsOptions): Promise<ModelInfo[]>;
     deleteModel(name: string): Promise<DeleteModelSummary>;
     clearKvCache(): Promise<KvCacheDeletionResult>;

package/dist-lib/lib/connect.js

@@ -6,19 +6,23 @@ import { z } from 'zod';
 import { settleOnClose } from './rpc-session.js';
 import { harnessClient } from '../spec/calls.js';
 import HRPC from '../spec/hrpc/index.js';
+import { encode } from '../spec/hrpc/messages.js';
 import { unsupportedKvCacheDeletion } from './capabilities/kv-cache.js';
+import { checkGoal, checkMaxToolRounds } from './capabilities/tool-turns.js';
+import { Agent } from './agent/index.js';
 import { readModelSourcePreview } from './capabilities/preview-model-source.js';
-import { validateEngineBoot } from './run-log-protocol.js';
+import { RunLog } from './run-log/index.js';
 import { hlog } from './log.js';
 import { assertEmbedDevice } from './models/embed-config.js';
 import { addonTaskType } from './models/model-task.js';
 import { errorCode, errorMessage, isRecord } from './guards.js';
 import { pushQueue } from './queue.js';
 import { stageFile, sweepStaging } from './staging.js';
+import { sweepSpill } from './spill.js';
 import { readInstall, readSetup } from './tools/skills/manifest-parse.js';
 import { SKILL_STATE } from './tools/skills/skill-state.js';
 import { asToolset } from './tools/toolsets.js';
-import { fromDownloadWire, fromWire, unpackVectors } from './wire.js';
+import { fromDownloadWire, fromKnowledgeHitWire, fromKnowledgeStatusWire, fromKnowledgeUpsertResultWire, fromWire, toKnowledgeUpsertWire, unpackVectors } from './wire.js';
 export const HARNESS_DIED = 'HARNESS_DIED';
 const PAUSE_GRACE_MS = 10_000;
 export function connectHarness(transport, options = {}) {
@@ -60,6 +64,7 @@ export class RemoteHarness extends EventEmitter {
     }
     async _open() {
         sweepStaging();
+        sweepSpill();
         let stream;
         try {
             stream = await this._transport();
@@ -92,7 +97,7 @@ export class RemoteHarness extends EventEmitter {
         this._session = session;
         this.emit('status', { state: 'running' });
         const models = session.client.modelEvents({});
-        models.on('data', (state) => this.emit('model', state));
+        models.on('data', (state) => this.emit('model', state.loaded ? { ...state, loaded: state.loaded.map(loadedModel) } : state));
         models.on('error', noop);
         if (this._customModels.length) {
             try {
@@ -104,7 +109,12 @@ export class RemoteHarness extends EventEmitter {
         }
         return session;
     }
-    async *completion(context) {
+    completion(context) {
+        return context.agents
+            ? Agent.follow({ completion: (hop) => this._hop(hop) }, { ...context, goal: undefined })
+            : this._hop(context);
+    }
+    async *_hop(context) {
         const runId = context.runId ?? b4a.toHex(randomBytes(16));
         if (context.signal?.aborted) {
             yield { type: 'aborted', runId };
@@ -119,6 +129,18 @@ export class RemoteHarness extends EventEmitter {
         if (explicitEmptyIdentity.length) {
             payload.explicitEmptyIdentity = explicitEmptyIdentity;
         }
+        if (context.knowledge) {
+            payload.knowledge = { scopes: [...context.knowledge.scopes] };
+        }
+        if (context.planMode) {
+            payload.planMode = true;
+        }
+        if (context.parentRunId) {
+            payload.parentRunId = context.parentRunId;
+        }
+        if (context.goal) {
+            payload.goal = checkGoal({ ...context.goal }, context.responseFormat);
+        }
         yield* this._run({
             type: 'start',
             runId,
@@ -130,10 +152,17 @@ export class RemoteHarness extends EventEmitter {
             generationParams: context.generationParams,
             responseFormat: context.responseFormat,
             captureInferenceCalls: context.captureInferenceCalls,
-            messages: context.messages?.map(({ role, content, attachments }) => ({
+            maxToolRounds: context.maxToolRounds === undefined || context.maxToolRounds === 0
+                ? undefined
+                : checkMaxToolRounds(context.maxToolRounds),
+            messages: context.messages?.map(({ role, content, attachments, toolCalls, toolCallId, name, id }) => ({
                 role,
                 content,
-                attachments: attachments?.map(({ path: file }) => ({ path: file }))
+                attachments: attachments?.map(({ path: file }) => ({ path: file })),
+                toolCalls,
+                toolCallId,
+                name,
+                id
             })),
             toolConfigs: context.toolConfigs,
             grantedDirs: context.grantedDirs,
@@ -227,11 +256,26 @@ export class RemoteHarness extends EventEmitter {
         };
         let pauseTimer;
         let started = false;
+        let failure = null;
+        const send = (frame) => {
+            if (!duplex)
+                return false;
+            try {
+                encode('@harness/completion-frame', frame);
+            }
+            catch (err) {
+                failure ??= new Error(`cannot encode ${String(frame.type)} frame: ${errorMessage(err)}`);
+                duplex.destroy(failure);
+                return false;
+            }
+            duplex.write(frame);
+            return true;
+        };
         const onAbort = () => {
             if (!pausable || !duplex || !started) {
                 return duplex?.destroy();
             }
-            duplex.write({ type: 'pause' });
+            send({ type: 'pause' });
             pauseTimer = setTimeout(() => duplex?.destroy(), this._pauseGraceMs);
         };
         try {
@@ -267,8 +311,21 @@ export class RemoteHarness extends EventEmitter {
                 yield { type: 'aborted', runId: activeRunId };
                 return;
             }
-            duplex.write(startFrame);
+            if (!send(startFrame)) {
+                throw failure;
+            }
             started = true;
+            if (context.input) {
+                void sendInput(context.input, (item) => {
+                    if (closed)
+                        return false;
+                    return send({
+                        type: item.mode,
+                        callId: item.id,
+                        messages: [{ role: 'user', content: item.text }]
+                    });
+                }).catch(noop);
+            }
             hlog('client wire open', { model: context.model, capability: open.capability });
             for await (const event of frames(duplex)) {
                 received++;
@@ -288,11 +345,11 @@ export class RemoteHarness extends EventEmitter {
                         .then(() => context.approve?.(approval))
                         .then((approved) => {
                         if (!closed) {
-                            duplex.write({ type: 'decision', callId, approved: approved === true });
+                            send({ type: 'decision', callId, approved: approved === true });
                         }
                     }, () => {
                         if (!closed) {
-                            duplex.write({ type: 'decision', callId, approved: false });
+                            send({ type: 'decision', callId, approved: false });
                         }
                     })
                         .catch((err) => hlog('approval reply failed', { callId, message: errorMessage(err) }));
@@ -303,11 +360,11 @@ export class RemoteHarness extends EventEmitter {
                     void bridgeAttach(event, context.attach)
                         .then((frame) => {
                         if (!closed) {
-                            duplex.write({ ...frame, callId });
+                            send({ ...frame, callId });
                         }
                     }, (err) => {
                         if (!closed) {
-                            duplex.write({
+                            send({
                                 type: 'attach-result',
                                 callId,
                                 message: errorMessage(err)
@@ -324,12 +381,12 @@ export class RemoteHarness extends EventEmitter {
                         if (closed) {
                             return reclaim();
                         }
-                        duplex.write({ ...frame, callId });
+                        send({ ...frame, callId });
                     }, (err) => {
                         if (closed) {
                             return reclaim();
                         }
-                        duplex.write({ type: 'fetch-result', callId, message: errorMessage(err) });
+                        send({ type: 'fetch-result', callId, message: errorMessage(err) });
                     })
                         .catch((err) => hlog('fetch reply failed', { callId, message: errorMessage(err) }));
                     continue;
@@ -339,7 +396,7 @@ export class RemoteHarness extends EventEmitter {
                     void bridgeDrive(event, context)
                         .then((frame) => {
                         if (!closed) {
-                            return duplex.write({ ...frame, callId });
+                            return send({ ...frame, callId });
                         }
                         const stagedPath = frame.payload?.path;
                         if (stagedPath) {
@@ -347,7 +404,7 @@ export class RemoteHarness extends EventEmitter {
                         }
                     }, (err) => {
                         if (!closed) {
-                            duplex.write({
+                            send({
                                 type: 'drive-result',
                                 callId,
                                 message: errorMessage(err)
@@ -367,11 +424,11 @@ export class RemoteHarness extends EventEmitter {
                     })
                         .then((frame) => {
                         if (!closed) {
-                            duplex.write({ ...frame, callId });
+                            send({ ...frame, callId });
                         }
                     }, (err) => {
                         if (!closed) {
-                            duplex.write({
+                            send({
                                 type: 'run-log-result',
                                 callId,
                                 message: errorMessage(err)
@@ -381,31 +438,12 @@ export class RemoteHarness extends EventEmitter {
                         .catch((err) => hlog('run-log reply failed', { callId, message: errorMessage(err) }));
                     continue;
                 }
-                if (event.type === 'rag-ask') {
-                    const callId = event.callId;
-                    void bridgeRag(event, context)
-                        .then((frame) => {
-                        if (!closed) {
-                            duplex.write({ ...frame, callId });
-                        }
-                    }, (err) => {
-                        if (!closed) {
-                            duplex.write({
-                                type: 'rag-result',
-                                callId,
-                                message: errorMessage(err)
-                            });
-                        }
-                    })
-                        .catch((err) => hlog('rag reply failed', { callId, message: errorMessage(err) }));
-                    continue;
-                }
                 if (event.type === 'question-ask') {
                     answerQuestion(event, {
                         askUser: context.askUser,
                         reply: (frame) => {
                             if (!closed) {
-                                duplex.write(frame);
+                                send(frame);
                             }
                         }
                     });
@@ -424,6 +462,9 @@ export class RemoteHarness extends EventEmitter {
             hlog('client wire ended', { received });
         }
         catch (err) {
+            if (failure) {
+                throw failure;
+            }
             if (context.signal?.aborted) {
                 if (!emittedAborted) {
                     yield { type: 'aborted', runId: activeRunId };
@@ -539,12 +580,19 @@ export class RemoteHarness extends EventEmitter {
         const pump = (async () => {
             try {
                 for await (const fragment of context.text) {
-                    duplex.write({ text: fragment });
+                    const frame = { text: fragment };
+                    try {
+                        encode('@harness/speak-stream-frame', frame);
+                    }
+                    catch (err) {
+                        throw new Error(`cannot encode speak frame: ${errorMessage(err)}`);
+                    }
+                    duplex.write(frame);
                 }
                 duplex.end();
             }
-            catch {
-                duplex.destroy();
+            catch (err) {
+                duplex.destroy(err);
             }
         })();
         try {
@@ -713,6 +761,30 @@ export class RemoteHarness extends EventEmitter {
         });
         return { unloaded: response.unloaded === true };
     }
+    async knowledgeUpsert(artifact) {
+        const { client } = await this._ensure();
+        const response = await client.knowledgeUpsert(toKnowledgeUpsertWire(artifact));
+        return fromKnowledgeUpsertResultWire(response, artifact.chunks.length);
+    }
+    async knowledgeRemove(artifactId) {
+        const { client } = await this._ensure();
+        const response = await client.knowledgeRemove({ artifactId });
+        return { removed: response.removed };
+    }
+    async knowledgeSearch(query) {
+        const { client } = await this._ensure();
+        const response = await client.knowledgeSearch({
+            text: query.text,
+            scopes: [...query.scopes],
+            k: query.k
+        });
+        return response.hits.map(fromKnowledgeHitWire);
+    }
+    async knowledgeStatus() {
+        const { client } = await this._ensure();
+        const response = await client.knowledgeStatus({});
+        return fromKnowledgeStatusWire(response);
+    }
     async list(options = {}) {
         const { client } = await this._ensure();
         const response = await client.listModels({
@@ -720,11 +792,14 @@ export class RemoteHarness extends EventEmitter {
             cachedOnly: options.cachedOnly,
             fullRegistry: options.fullRegistry
         });
-        return (response.models ?? []).map(({ actualSize, label, ...row }) => ({
+        return (response.models ?? []).map(({ actualSize, label, fit, fitBasis, fitEvidence, ...row }) => ({
             ...row,
             actualSize: actualSize || undefined,
             label: label || undefined,
-            taskType: addonTaskType(row.type)
+            taskType: addonTaskType(row.type),
+            fit: (fit || undefined),
+            fitBasis: (fitBasis || undefined),
+            fitEvidence: (fitEvidence || undefined)
         }));
     }
     async deleteModel(name) {
@@ -825,7 +900,7 @@ export class RemoteHarness extends EventEmitter {
         const snapshot = await diagnostics.call(client, {});
         const device = snapshot?.device;
         return {
-            models: (snapshot?.models ?? []).map((row) => ({ model: row.model, refs: row.refs })),
+            models: (snapshot?.models ?? []).map(loadedModel),
             suspended: snapshot?.suspended ?? false,
             sdkLoaded: snapshot?.sdkLoaded ?? false,
             toolNames: snapshot?.toolNames ?? [],
@@ -834,6 +909,23 @@ export class RemoteHarness extends EventEmitter {
         };
     }
 }
+function loadedModel({ model, refs, fit }) {
+    if (!fit) {
+        return { model, refs };
+    }
+    const { verdict, reason, plan, deviceBytes, hostBytes } = fit;
+    return {
+        model,
+        refs,
+        fit: {
+            verdict,
+            reason,
+            plan: plan ?? undefined,
+            deviceBytes: deviceBytes || undefined,
+            hostBytes: hostBytes || undefined
+        }
+    };
+}
 function parseSkillState(value) {
     return value ? value : SKILL_STATE.failed;
 }
@@ -880,7 +972,10 @@ function knobs(agent) {
         imageHeight: agent.imageHeight ?? undefined,
         approvalMode: agent.approvalMode ?? undefined,
         disabledToolsets: agent.disabledToolsets ?? undefined,
-        sandboxMode: agent.sandboxMode ?? undefined
+        sandboxMode: agent.sandboxMode ?? undefined,
+        handoffs: agent.handoffs?.map(({ id, description }) => ({ id, description })),
+        plan: agent.plan ?? undefined,
+        model: agent.model ?? undefined
     };
 }
 function explicitEmptyIdentityFields(context) {
@@ -1011,6 +1106,16 @@ async function bridgeDrive(event, context) {
         return { type: 'drive-result', message: errorMessage(err) };
     }
 }
+async function sendInput(input, send) {
+    const iterator = input[Symbol.asyncIterator]();
+    for (;;) {
+        const next = await iterator.next();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        if (next.done || !send(next.value)) {
+            return;
+        }
+    }
+}
 function answerQuestion(event, { askUser, reply }) {
     const callId = event.callId;
     if (!askUser) {
@@ -1072,7 +1177,7 @@ function validateHostRunLogLease(lease, runId) {
         throw new Error('host returned an invalid run-log lease');
     }
     if (lease.boot) {
-        validateEngineBoot(lease.boot);
+        RunLog.validateEngineBoot(lease.boot);
     }
     const metadata = lease.boot?.metadata;
     if (metadata && metadata.runId !== runId) {
@@ -1087,7 +1192,8 @@ function approvalCall(event) {
         resource: event.resource ?? null,
         effect: event.effect === 'read' ? 'read' : 'write',
         intent: event.intent || null,
-        display: isToolCallDisplay(event.display) ? event.display : null
+        display: isToolCallDisplay(event.display) ? event.display : null,
+        quote: event.question || null
     };
     if (typeof identity.callId === 'string') {
         approval.callId = identity.callId;
@@ -1145,24 +1251,6 @@ function awaitWithAbort(promise, signal) {
         });
     });
 }
-async function bridgeRag(event, context) {
-    if (!context.ragSearch) {
-        return {
-            type: 'rag-result',
-            result: { enabled: false, indexEmpty: true, hasKnowledge: false, hits: [] }
-        };
-    }
-    try {
-        const result = await context.ragSearch({
-            query: event.query ?? '',
-            limit: event.limit ?? undefined
-        });
-        return { type: 'rag-result', result };
-    }
-    catch (err) {
-        return { type: 'rag-result', message: errorMessage(err) };
-    }
-}
 async function* frames(stream) {
     const queue = pushQueue();
     let error = null;

package/dist-lib/lib/context-window.d.ts

@@ -1,7 +1,9 @@
-import type { Message } from './capabilities/completion.ts';
+import type { Message } from './contract/index.ts';
 export declare const TOOL_RESULT_TRUNCATION_MARKER = "\n[tool result truncated for context]\n";
+export declare function compactedFrom(message: Message): Message | undefined;
 export interface ContextCandidate {
     history: Message[];
     droppedTurns: number;
 }
-export declare function contextCandidates(history: Message[]): ContextCandidate[];
+export declare function contextCandidates(history: Message[], ...nudges: string[]): ContextCandidate[];
+export declare function compactContent(content: string, target: number): string;