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

package/dist-lib/{lib → plugins}/web-search/engines/duckduckgo.js

@@ -1,5 +1,5 @@
 import { fetchHtml } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 import { urlMatchesHost } from '../url-helpers.js';
 function extractDdgUrl(raw) {
     if (raw.includes('uddg=')) {
@@ -90,9 +90,12 @@ function parseUddgFallback(html) {
     }
     return results;
 }
+export function duckDuckGoUrl() {
+    return 'https://html.duckduckgo.com/html/';
+}
 export async function searchDuckDuckGo(query, fetcher, signal) {
     const body = `q=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, 'https://html.duckduckgo.com/html/', {
+    const html = await fetchHtml(fetcher, duckDuckGoUrl(), {
         method: 'POST',
         headers: {
             'Content-Type': 'application/x-www-form-urlencoded',

package/dist-lib/{lib → plugins}/web-search/engines/google.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function googleUrl(query: string): string;
 export declare function searchGoogle(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/{lib → plugins}/web-search/engines/google.js

@@ -1,7 +1,7 @@
 import { fetchHtml } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 import { urlMatchesHost } from '../url-helpers.js';
-import { GOOGLE_GSA_UA } from '../user-agents.js';
+import { GOOGLE_GSA_UA } from '../../../lib/helpers/user-agents.js';
 function resolveGoogleUrl(rawUrl) {
     if (rawUrl.startsWith('/url?q=')) {
         return decodeURIComponent(rawUrl.slice(7).split('&')[0] || '');
@@ -78,9 +78,11 @@ function parseH3Fallback(html) {
     }
     return results;
 }
+export function googleUrl(query) {
+    return `https://www.google.com/search?q=${encodeURIComponent(query)}&hl=en&ie=utf8&oe=utf8&filter=0`;
+}
 export async function searchGoogle(query, fetcher, signal) {
-    const url = `https://www.google.com/search?q=${encodeURIComponent(query)}&hl=en&ie=utf8&oe=utf8&filter=0`;
-    const html = await fetchHtml(fetcher, url, {
+    const html = await fetchHtml(fetcher, googleUrl(query), {
         headers: { 'User-Agent': GOOGLE_GSA_UA, Accept: '*/*' },
         cookies: { CONSENT: 'YES+' },
         signal

package/dist-lib/{lib → plugins}/web-search/engines/wikipedia.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function wikipediaUrl(query: string): string;
 export declare function searchWikipedia(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/{lib → plugins}/web-search/engines/wikipedia.js

@@ -1,5 +1,5 @@
 import { fetchJson } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 function extractSearchItems(data) {
     if (typeof data !== 'object' || data === null) {
         return [];
@@ -25,9 +25,11 @@ function extractSearchItems(data) {
     }
     return items;
 }
+export function wikipediaUrl(query) {
+    return `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&srlimit=5&utf8=1`;
+}
 export async function searchWikipedia(query, fetcher, signal) {
-    const apiUrl = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&srlimit=5&utf8=1`;
-    const data = await fetchJson(fetcher, apiUrl, { signal });
+    const data = await fetchJson(fetcher, wikipediaUrl(query), { signal });
     const items = extractSearchItems(data);
     return items.map((item, idx) => ({
         title: item.title,

package/dist-lib/{lib → plugins}/web-search/engines/yahoo.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function yahooUrl(query: string): string;
 export declare function searchYahoo(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/{lib → plugins}/web-search/engines/yahoo.js

@@ -1,5 +1,5 @@
 import { fetchHtml } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 import { urlMatchesHost } from '../url-helpers.js';
 function decodeRuUrl(encoded) {
     try {
@@ -70,9 +70,11 @@ function parseRuFallback(html) {
     }
     return results;
 }
+export function yahooUrl(query) {
+    return `https://search.yahoo.com/search?p=${encodeURIComponent(query)}`;
+}
 export async function searchYahoo(query, fetcher, signal) {
-    const url = `https://search.yahoo.com/search?p=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, url, { signal });
+    const html = await fetchHtml(fetcher, yahooUrl(query), { signal });
     const primary = parseAlgoBlocks(html);
     if (primary.length > 0) {
         return primary;

package/dist-lib/{lib → plugins}/web-search/fetch-html.js

@@ -1,5 +1,5 @@
 import { AbortController } from 'bare-abort-controller';
-import { BROWSER_UA } from './user-agents.js';
+import { BROWSER_UA } from '../../lib/helpers/user-agents.js';
 export const ENGINE_TIMEOUT_MS = 8000;
 export const MAX_HTML_CHARS = 2_000_000;
 export class TimeoutError extends Error {

package/dist-lib/plugins/web-search/index.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessPlugin, PluginSetup } from '../../lib/plugins/index.ts';
+import { type EngineName } from './engine-registry.ts';
+export type { EngineName } from './engine-registry.ts';
+export interface WebSearchOptions {
+    readonly engines?: readonly EngineName[];
+    readonly maxResults?: number;
+    readonly read?: readonly string[];
+}
+export declare class WebSearchPlugin implements HarnessPlugin {
+    readonly name = "web-search";
+    readonly api = 1;
+    readonly read: readonly string[] | undefined;
+    readonly engines: readonly EngineName[];
+    readonly maxResults: number | undefined;
+    constructor({ engines, maxResults, read }?: WebSearchOptions);
+    validate(): string | null;
+    setup(): PluginSetup;
+}

package/dist-lib/plugins/web-search/index.js

@@ -0,0 +1,33 @@
+import { PluginRegistry } from '../../lib/plugins/index.js';
+import { ENGINES } from './engine-registry.js';
+import { createWebSearchTool } from './tool.js';
+export class WebSearchPlugin {
+    name = 'web-search';
+    api = PluginRegistry.API_VERSION;
+    read;
+    engines;
+    maxResults;
+    constructor({ engines = ENGINES.map((engine) => engine.name), maxResults, read } = {}) {
+        this.engines = engines;
+        this.maxResults = maxResults;
+        this.read = read;
+    }
+    validate() {
+        if (this.engines.length === 0) {
+            return 'engines must name at least one engine';
+        }
+        const unknown = this.engines.find((name) => !ENGINES.some((engine) => engine.name === name));
+        if (unknown !== undefined) {
+            return `unknown engine '${unknown}'`;
+        }
+        const max = this.maxResults;
+        if (max !== undefined && !(Number.isInteger(max) && max > 0)) {
+            return 'maxResults must be a positive integer';
+        }
+        return null;
+    }
+    setup() {
+        const engines = this.engines.flatMap((name) => ENGINES.filter((engine) => engine.name === name));
+        return { tools: [createWebSearchTool(engines, this.maxResults)] };
+    }
+}

package/dist-lib/{lib → plugins}/web-search/orchestrator.d.ts

@@ -1,4 +1,5 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import { type EngineEntry } from './engine-registry.ts';
 import type { Fetcher, WebSearchResult } from './types.ts';
 export interface EngineSummaryEntry {
     readonly engine: string;
@@ -12,7 +13,8 @@ export interface SearchWebResult {
 }
 export declare function classifyEngineError(reason: unknown): 'timeout' | 'error';
 export interface SearchWebOptions {
+    readonly engines?: readonly EngineEntry[];
     readonly maxResults?: number;
     readonly signal?: BareAbortSignal;
 }
-export declare function searchWeb(fetcher: Fetcher, query: string, { maxResults, signal }?: SearchWebOptions): Promise<SearchWebResult>;
+export declare function searchWeb(fetcher: Fetcher, query: string, { engines, maxResults, signal }?: SearchWebOptions): Promise<SearchWebResult>;

package/dist-lib/{lib → plugins}/web-search/orchestrator.js

@@ -23,10 +23,10 @@ function processSettledResult(engineName, result, { outcomes, engineSummary }) {
         });
     }
 }
-export async function searchWeb(fetcher, query, { maxResults = DEFAULT_MAX_RESULTS, signal } = {}) {
-    const settled = await Promise.allSettled(ENGINES.map(async ({ name, fn }) => {
+export async function searchWeb(fetcher, query, { engines = ENGINES, maxResults = DEFAULT_MAX_RESULTS, signal } = {}) {
+    const settled = await Promise.allSettled(engines.map(async ({ name, search }) => {
         const start = Date.now();
-        const results = await fn(query, fetcher, signal);
+        const results = await search(query, fetcher, signal);
         return {
             engine: name,
             results: [...results],
@@ -35,8 +35,8 @@ export async function searchWeb(fetcher, query, { maxResults = DEFAULT_MAX_RESUL
     }));
     const outcomes = [];
     const engineSummary = [];
-    for (let i = 0; i < ENGINES.length; i++) {
-        const engine = ENGINES[i];
+    for (let i = 0; i < engines.length; i++) {
+        const engine = engines[i];
         const settledResult = settled[i];
         if (!engine || !settledResult) {
             continue;

package/dist-lib/plugins/web-search/tool.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from '../../lib/contract/index.ts';
+import type { EngineEntry } from './engine-registry.ts';
+export declare function createWebSearchTool(engines: readonly EngineEntry[], maxResults?: number): ToolDefinition;

package/dist-lib/{lib/tools/web-search.js → plugins/web-search/tool.js}

@@ -1,19 +1,13 @@
-import defaultFetch from '#fetch';
-import { errorMessage } from '../guards.js';
-import { formatResultsForPrompt } from '../web-search/format-results.js';
-import { searchWeb } from '../web-search/orchestrator.js';
-const nodeFetch = async (url, init) => {
-    const res = await defaultFetch(url, init);
-    return { ok: res.ok, status: res.status, text: () => res.text() };
-};
+import { errorMessage } from '../../lib/guards.js';
+import { formatResultsForPrompt } from './format-results.js';
+import { searchWeb } from './orchestrator.js';
 const SMALL_CONTEXT_TOKENS = 12_288;
 const SMALL_CONTEXT_RESULTS = 8;
 const LARGE_CONTEXT_RESULTS = 12;
 function resultBudget(ctxSize) {
     return ctxSize && ctxSize <= SMALL_CONTEXT_TOKENS ? SMALL_CONTEXT_RESULTS : LARGE_CONTEXT_RESULTS;
 }
-export function createWebSearchTool({ fetch } = {}) {
-    const fetcher = fetch ?? nodeFetch;
+export function createWebSearchTool(engines, maxResults) {
     return {
         name: 'web_search',
         toolset: 'web-search',
@@ -30,17 +24,27 @@ export function createWebSearchTool({ fetch } = {}) {
             required: ['query']
         },
         effect: () => 'read',
+        egress: (args) => {
+            const query = args.query;
+            return typeof query === 'string' && query.trim().length > 0
+                ? engines.map((engine) => engine.url(query))
+                : null;
+        },
         async execute(args, ctx) {
             const query = args.query;
             if (typeof query !== 'string' || query.trim().length === 0) {
                 return { error: 'query must be a non-empty string' };
             }
+            if (!ctx?.fetch) {
+                return { error: 'web_search has no network access' };
+            }
             try {
-                const { results, engineSummary } = await searchWeb(fetcher, query, {
-                    maxResults: resultBudget(ctx?.ctxSize),
-                    signal: ctx?.signal
+                const { results, engineSummary } = await searchWeb(ctx.fetch, query, {
+                    engines,
+                    maxResults: maxResults ?? resultBudget(ctx.ctxSize),
+                    signal: ctx.signal
                 });
-                if (ctx?.signal?.aborted) {
+                if (ctx.signal?.aborted) {
                     return { error: 'web_search cancelled' };
                 }
                 if (results.length > 0) {

package/dist-lib/plugins/web-search/types.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/schema/generate.js

@@ -33,7 +33,9 @@ export function writeBind(builder, outFile) {
             s += '          }\n';
             s += '          stream.end();\n';
             s += '        } catch (err) {\n';
-            s += '          stream.destroy(err);\n';
+            s += '          const error = err instanceof Error ? err : new Error(String(err));\n';
+            s += '          stream.writeStream?.destroy(error);\n';
+            s += '          stream.destroy(error);\n';
             s += '        }\n';
             s += '      })();\n';
             s += '    });\n';
@@ -44,7 +46,8 @@ export function writeBind(builder, outFile) {
         else if (handler.response?.stream) {
             s += `    rpc.${on}((out) => {\n`;
             s += `      const src = Readable.from(api.${method}(out.data));\n`;
-            s += '      src.on("error", (err) => out.writeStream?.destroy(err));\n';
+            s +=
+                '      src.on("error", (err) => out.writeStream?.destroy(err instanceof Error ? err : new Error(String(err))));\n';
             s += '      pipeline(src, out, noop);\n';
             s += '      out.writeStream?.on("close", () => src.destroy());\n';
             s += '    });\n';

package/dist-lib/schema/harness.js

@@ -4,6 +4,13 @@ export function registerHarnessTypes(ns) {
     ns.register({ name: 'reasoning', enum: ['inherit', 'enabled', 'disabled'], strings: true });
     ns.register({ name: 'embedding-device', enum: ['gpu', 'cpu'], strings: true });
     ns.register({ name: 'approval-mode', enum: ['ask', 'skip-all'], strings: true });
+    ns.register({
+        name: 'agent-handoff',
+        fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'description', type: 'string', required: true }
+        ]
+    });
     ns.register({
         name: 'agent-knobs',
         fields: [
@@ -24,7 +31,10 @@ export function registerHarnessTypes(ns) {
             { name: 'imageHeight', type: 'uint' },
             { name: 'approvalMode', type: '@harness/approval-mode' },
             { name: 'disabledToolsets', type: 'string', array: true },
-            { name: 'sandboxMode', type: 'bool' }
+            { name: 'sandboxMode', type: 'bool' },
+            { name: 'handoffs', type: '@harness/agent-handoff', array: true },
+            { name: 'plan', type: 'bool' },
+            { name: 'model', type: 'string' }
         ]
     });
     ns.register({
@@ -41,7 +51,11 @@ export function registerHarnessTypes(ns) {
         fields: [
             { name: 'role', type: '@harness/message-role', required: true },
             { name: 'content', type: 'string', required: true },
-            { name: 'attachments', type: '@harness/message-attachment', array: true }
+            { name: 'attachments', type: '@harness/message-attachment', array: true },
+            { name: 'toolCalls', type: 'json' },
+            { name: 'toolCallId', type: 'string' },
+            { name: 'name', type: 'string' },
+            { name: 'id', type: 'string' }
         ]
     });
     ns.register({
@@ -72,7 +86,9 @@ export function registerHarnessTypes(ns) {
             'drive-result',
             'invoke',
             'run-log-result',
-            'pause'
+            'pause',
+            'steer',
+            'follow-up'
         ],
         strings: true
     });
@@ -116,7 +132,8 @@ export function registerHarnessTypes(ns) {
             { name: 'capability', type: 'string' },
             { name: 'arguments', type: 'json' },
             { name: 'enhance', type: 'string' },
-            { name: 'runId', type: 'string' }
+            { name: 'runId', type: 'string' },
+            { name: 'maxToolRounds', type: 'uint' }
         ]
     });
     ns.register({
@@ -145,7 +162,11 @@ export function registerHarnessTypes(ns) {
             'paused',
             'recovery-required',
             'round-reset',
-            'run-log-append'
+            'run-log-append',
+            'input',
+            'goal',
+            'fold',
+            'input-rejected'
         ],
         strings: true
     });
@@ -190,11 +211,35 @@ export function registerHarnessTypes(ns) {
         enum: ['loading', 'downloading', 'ready', 'error', 'unloading', 'unloaded', 'downloaded'],
         strings: true
     });
+    ns.register({
+        name: 'load-fit-verdict',
+        enum: ['fit', 'does-not-fit', 'unknown'],
+        strings: true
+    });
+    ns.register({
+        name: 'load-fit-plan',
+        fields: [
+            { name: 'nCtx', type: 'int', required: true },
+            { name: 'nGpuLayers', type: 'int', required: true },
+            { name: 'nGpuDevices', type: 'int', required: true }
+        ]
+    });
+    ns.register({
+        name: 'load-fit',
+        fields: [
+            { name: 'verdict', type: '@harness/load-fit-verdict', required: true },
+            { name: 'reason', type: 'string', required: true },
+            { name: 'plan', type: '@harness/load-fit-plan' },
+            { name: 'deviceBytes', type: 'float64' },
+            { name: 'hostBytes', type: 'float64' }
+        ]
+    });
     ns.register({
         name: 'loaded-model',
         fields: [
             { name: 'model', type: 'string', required: true },
-            { name: 'refs', type: 'uint', required: true }
+            { name: 'refs', type: 'uint', required: true },
+            { name: 'fit', type: '@harness/load-fit' }
         ]
     });
     ns.register({
@@ -352,7 +397,10 @@ export function registerHarnessTypes(ns) {
             { name: 'expectedSize', type: 'uint', required: true },
             { name: 'actualSize', type: 'uint' },
             { name: 'label', type: 'string' },
-            { name: 'isLoading', type: 'bool' }
+            { name: 'isLoading', type: 'bool' },
+            { name: 'fit', type: 'string' },
+            { name: 'fitBasis', type: 'string' },
+            { name: 'fitEvidence', type: 'string' }
         ]
     });
     ns.register({
@@ -753,6 +801,89 @@ export function registerHarnessTypes(ns) {
         name: 'unload-model-response',
         fields: [{ name: 'unloaded', type: 'bool', required: true }]
     });
+    ns.register({
+        name: 'knowledge-chunk',
+        fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'text', type: 'string', required: true },
+            { name: 'metadata', type: 'json' }
+        ]
+    });
+    ns.register({
+        name: 'knowledge-upsert-request',
+        fields: [
+            { name: 'artifactId', type: 'string', required: true },
+            { name: 'version', type: 'string' },
+            { name: 'scope', type: 'string', required: true },
+            { name: 'chunks', type: '@harness/knowledge-chunk', array: true, required: true },
+            { name: 'model', type: 'string' },
+            { name: 'dimensions', type: 'uint' },
+            { name: 'vectors', type: 'buffer' }
+        ]
+    });
+    ns.register({
+        name: 'knowledge-upsert-response',
+        fields: [
+            { name: 'added', type: 'uint', required: true },
+            { name: 'model', type: 'string' },
+            { name: 'dimensions', type: 'uint' },
+            { name: 'vectors', type: 'buffer' }
+        ]
+    });
+    ns.register({
+        name: 'knowledge-remove-request',
+        fields: [{ name: 'artifactId', type: 'string', required: true }]
+    });
+    ns.register({
+        name: 'knowledge-remove-response',
+        fields: [{ name: 'removed', type: 'uint', required: true }]
+    });
+    ns.register({
+        name: 'knowledge-search-request',
+        fields: [
+            { name: 'text', type: 'string', required: true },
+            { name: 'scopes', type: 'string', array: true, required: true },
+            { name: 'k', type: 'uint' }
+        ]
+    });
+    ns.register({
+        name: 'knowledge-hit',
+        fields: [
+            { name: 'artifactId', type: 'string', required: true },
+            { name: 'chunkId', type: 'string', required: true },
+            { name: 'scope', type: 'string', required: true },
+            { name: 'text', type: 'string', required: true },
+            { name: 'score', type: 'float64', required: true },
+            { name: 'metadata', type: 'json' }
+        ]
+    });
+    ns.register({
+        name: 'knowledge-search-response',
+        fields: [{ name: 'hits', type: '@harness/knowledge-hit', array: true, required: true }]
+    });
+    ns.register({
+        name: 'knowledge-artifact-status',
+        fields: [
+            { name: 'artifactId', type: 'string', required: true },
+            { name: 'version', type: 'string' },
+            { name: 'scope', type: 'string', required: true },
+            { name: 'chunks', type: 'uint', required: true }
+        ]
+    });
+    ns.register({
+        name: 'knowledge-status-response',
+        fields: [
+            { name: 'model', type: 'string', required: true },
+            { name: 'dimensions', type: 'uint', required: true },
+            { name: 'chunks', type: 'uint', required: true },
+            {
+                name: 'artifacts',
+                type: '@harness/knowledge-artifact-status',
+                array: true,
+                required: true
+            }
+        ]
+    });
 }
 export function registerHarnessApi(api) {
     api.register({
@@ -920,4 +1051,24 @@ export function registerHarnessApi(api) {
         request: { name: '@harness/unload-model-request', stream: false },
         response: { name: '@harness/unload-model-response', stream: false }
     });
+    api.register({
+        name: 'knowledge-upsert',
+        request: { name: '@harness/knowledge-upsert-request', stream: false },
+        response: { name: '@harness/knowledge-upsert-response', stream: false }
+    });
+    api.register({
+        name: 'knowledge-remove',
+        request: { name: '@harness/knowledge-remove-request', stream: false },
+        response: { name: '@harness/knowledge-remove-response', stream: false }
+    });
+    api.register({
+        name: 'knowledge-search',
+        request: { name: '@harness/knowledge-search-request', stream: false },
+        response: { name: '@harness/knowledge-search-response', stream: false }
+    });
+    api.register({
+        name: 'knowledge-status',
+        request: { name: '@harness/empty', stream: false },
+        response: { name: '@harness/knowledge-status-response', stream: false }
+    });
 }

package/dist-lib/spec/bind.js

@@ -16,7 +16,9 @@ export function bindApi(rpc, api) {
           }
           stream.end();
         } catch (err) {
-          stream.destroy(err);
+          const error = err instanceof Error ? err : new Error(String(err));
+          stream.writeStream?.destroy(error);
+          stream.destroy(error);
         }
       })();
     });
@@ -24,7 +26,7 @@ export function bindApi(rpc, api) {
   if (api.modelEvents) {
     rpc.onModelEvents((out) => {
       const src = Readable.from(api.modelEvents(out.data));
-      src.on("error", (err) => out.writeStream?.destroy(err));
+      src.on("error", (err) => out.writeStream?.destroy(err instanceof Error ? err : new Error(String(err))));
       pipeline(src, out, noop);
       out.writeStream?.on("close", () => src.destroy());
     });
@@ -32,7 +34,7 @@ export function bindApi(rpc, api) {
   if (api.download) {
     rpc.onDownload((out) => {
       const src = Readable.from(api.download(out.data));
-      src.on("error", (err) => out.writeStream?.destroy(err));
+      src.on("error", (err) => out.writeStream?.destroy(err instanceof Error ? err : new Error(String(err))));
       pipeline(src, out, noop);
       out.writeStream?.on("close", () => src.destroy());
     });
@@ -86,7 +88,9 @@ export function bindApi(rpc, api) {
           }
           stream.end();
         } catch (err) {
-          stream.destroy(err);
+          const error = err instanceof Error ? err : new Error(String(err));
+          stream.writeStream?.destroy(error);
+          stream.destroy(error);
         }
       })();
     });
@@ -139,4 +143,16 @@ export function bindApi(rpc, api) {
   if (api.unloadModel) {
     rpc.onUnloadModel((req) => api.unloadModel(req));
   }
+  if (api.knowledgeUpsert) {
+    rpc.onKnowledgeUpsert((req) => api.knowledgeUpsert(req));
+  }
+  if (api.knowledgeRemove) {
+    rpc.onKnowledgeRemove((req) => api.knowledgeRemove(req));
+  }
+  if (api.knowledgeSearch) {
+    rpc.onKnowledgeSearch((req) => api.knowledgeSearch(req));
+  }
+  if (api.knowledgeStatus) {
+    rpc.onKnowledgeStatus((req) => api.knowledgeStatus(req));
+  }
 }

package/dist-lib/spec/calls.js

@@ -43,5 +43,9 @@ export function harnessClient(rpc) {
     setModelIdleTimeout: (input) => rpc.setModelIdleTimeout(input),
     loadModel: (input) => rpc.loadModel(input),
     unloadModel: (input) => rpc.unloadModel(input),
+    knowledgeUpsert: (input) => rpc.knowledgeUpsert(input),
+    knowledgeRemove: (input) => rpc.knowledgeRemove(input),
+    knowledgeSearch: (input) => rpc.knowledgeSearch(input),
+    knowledgeStatus: (input) => rpc.knowledgeStatus(input),
   };
 }

package/dist-lib/spec/hrpc/hrpc.json

@@ -429,6 +429,58 @@
         "stream": false
       },
       "version": 1
+    },
+    {
+      "id": 33,
+      "name": "@harness/knowledge-upsert",
+      "request": {
+        "name": "@harness/knowledge-upsert-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/knowledge-upsert-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 34,
+      "name": "@harness/knowledge-remove",
+      "request": {
+        "name": "@harness/knowledge-remove-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/knowledge-remove-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 35,
+      "name": "@harness/knowledge-search",
+      "request": {
+        "name": "@harness/knowledge-search-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/knowledge-search-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 36,
+      "name": "@harness/knowledge-status",
+      "request": {
+        "name": "@harness/empty",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/knowledge-status-response",
+        "stream": false
+      },
+      "version": 1
     }
   ]
 }