@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/tools/research/web-fetch.js

@@ -4,7 +4,7 @@
  * One URL in, extracted text out: HTML becomes Markdown (Readability over a
  * `linkedom` DOM, then Turndown, with the body text as the fallback), a PDF
  * becomes the text of its first 100 pages through `pdf-parse`, and a text or
- * JSON body passes through. A bad scheme, a denied approval, an HTTP error, an
+ * JSON body passes through. A bad scheme, an internal address, an HTTP error, an
  * oversized body, a redirect chain past the limit, and a body the tool cannot
  * extract are all normal results on the ok channel — never a failure of the
  * turn.
@@ -15,9 +15,11 @@
  * runs no name lookup for a literal — and a name classifies inside the `lookup`
  * hook of `node:http`/`node:https`, over every address of the resolution,
  * because the connect layer falls back to a later address after an earlier one
- * fails. A guarded hop is destroyed before the user is asked, and an approval
- * re-sends the hop.
+ * fails. A guarded hop is destroyed before it connects, and the call gives a
+ * refusal that names the origin. The tool asks nothing.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { lookup as dnsLookup } from "node:dns";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
@@ -28,8 +30,9 @@ import { Readability } from "@mozilla/readability";
 import { parseHTML } from "linkedom";
 import TurndownService from "turndown";
 import { z } from "zod";
+import { presentLast } from "../../lib/present.js";
+import { hasWhitespace } from "../../lib/text.js";
 import { keptTextOf, pairSafeIndex, TOOL_RESULT_CAP, toolOutputRef } from "../../loop/tool-output.js";
-import { AskRejectedError } from "../approval/contract.js";
 import { defineTool } from "../define-tool.js";
 import { HARNESS_USER_AGENT } from "../lib/api-utils.js";
 import { isGuardedAddress } from "./guarded-address.js";
@@ -66,7 +69,7 @@ function hopTimeoutError(url) {
 function isAbort(error, ctx) {
     return error.name === "AbortError" || ctx.signal.aborted;
 }
-/** The origin of an `always` approval: scheme, host, and the port the connection uses, with the default filled in. */
+/** The origin of a URL: scheme, host, and the port the connection uses, with the default filled in. */
 function originOf(url) {
     const port = url.port !== "" ? url.port : url.protocol === "https:" ? "443" : "80";
     return `${url.protocol}//${url.hostname}:${port}`;
@@ -100,37 +103,17 @@ function withoutCredentials(url) {
     clean.password = "";
     return clean;
 }
-async function askForOrigin(url, origin, ctx) {
-    const request = {
-        title: "web_fetch: read a page from a guarded address",
-        command: url.toString(),
-        grantKey: `web_fetch:${origin}`,
-        detail: `The address of ${url.hostname} is in a guarded range (loopback, private, link-local, or reserved). ` +
-            `An "always" answer approves every later web_fetch of the origin ${origin}; a "once" answer approves this call only.`,
+function refusedGuarded(url) {
+    return {
+        status: "refused",
+        text: `web_fetch did not read ${url.toString()}: the origin ${originOf(url)} has an internal address ` +
+            `(loopback, private, link-local, or reserved), and web_fetch reads no internal address.`,
     };
-    try {
-        await ctx.ask(request);
-        return { kind: "approved" };
-    }
-    catch (error) {
-        if (error instanceof AskRejectedError) {
-            return {
-                kind: "denied",
-                output: {
-                    status: "refused",
-                    text: `web_fetch did not read ${url.toString()}: the guarded address ${url.hostname} was not approved.`,
-                    ...(error.feedback !== undefined ? { feedback: error.feedback } : {}),
-                },
-            };
-        }
-        throw error;
-    }
 }
 /**
  * Send one hop. The `lookup` hook classifies every address of each resolution
- * before the connect can use any of it: when a guarded address appears and the
- * origin is not approved, the hook answers nothing and destroys the request, so
- * no socket opens while the user reads the prompt.
+ * before the connect can use any of it: when a guarded address appears, the hook
+ * answers nothing and destroys the request, so no socket opens.
  */
 function sendHop(url, state) {
     return new Promise((resolve, reject) => {
@@ -169,8 +152,7 @@ function sendHop(url, state) {
                         callback(error, "");
                         return;
                     }
-                    const guarded = addresses.some((entry) => isGuardedAddress(entry.address));
-                    if (guarded && !state.approvedOrigins.has(originOf(url))) {
+                    if (addresses.some((entry) => isGuardedAddress(entry.address))) {
                         // With no callback the connect never starts, and the destroy
                         // carries the signal out through the error event.
                         request.destroy(new GuardedHopSignal());
@@ -193,6 +175,7 @@ function sendHop(url, state) {
             },
         });
         // The socket-idle timeout below does not bound a server that trickles bytes, so a wall clock bounds the whole hop.
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- a guard, not a wait: it destroys the in-flight hop at the wall clock, unrefs so it never holds the process, and the settle disposes it.
         const deadline = setTimeout(() => {
             const error = hopTimeoutError(url);
             liveResponse?.destroy(error);
@@ -289,6 +272,16 @@ const MAX_HTML_NESTING = 512;
 const VOID_TAGS = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
 /** Elements whose content is raw text: the scanner skips to their close tag, because markup inside them is not structure. */
 const RAW_TEXT_TAGS = new Set(["script", "style", "textarea", "title", "xmp", "noscript", "iframe", "noembed"]);
+/** A raw-text close repeats the element name in any letter case and ends at whitespace, a slash, or the bracket. */
+function isRawTextClose(html, at, name) {
+    if (html.slice(at + 2, at + 2 + name.length).toLowerCase() !== name)
+        return false;
+    const next = html.charAt(at + 2 + name.length);
+    return next === ">" || next === "/" || hasWhitespace(next);
+}
+function isTagNameChar(char) {
+    return (char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || (char >= "0" && char <= "9") || char === ":" || char === "-";
+}
 /** An opening tag in a family closes its open peers before it nests — the implied-end rules that keep a list or a table row of any length flat. */
 const IMPLIED_CLOSE_PEERS = {
     li: new Set(["li"]),
@@ -316,10 +309,17 @@ const IMPLIED_CLOSE_PEERS = {
 export function htmlNestingDepth(html) {
     let max = 0;
     const stack = [];
-    const tagName = (start, end) => html
-        .slice(start, end)
-        .match(/^[a-zA-Z][a-zA-Z0-9:-]*/)?.[0]
-        ?.toLowerCase() ?? "";
+    const tagName = (start, end) => {
+        const text = html.slice(start, end);
+        const first = text.charAt(0);
+        const isLetter = (first >= "a" && first <= "z") || (first >= "A" && first <= "Z");
+        if (!isLetter)
+            return "";
+        let at = 1;
+        while (at < text.length && isTagNameChar(text.charAt(at)))
+            at++;
+        return text.slice(0, at).toLowerCase();
+    };
     let i = 0;
     while (i < html.length) {
         if (html[i] !== "<") {
@@ -372,17 +372,17 @@ export function htmlNestingDepth(html) {
         if (name === "")
             continue;
         if (RAW_TEXT_TAGS.has(name)) {
-            const close = new RegExp(`</${name}(?=[\\s/>])`, "gi");
-            close.lastIndex = i;
-            const found = close.exec(html);
-            i = found === null ? html.length : found.index + found[0].length;
+            let close = html.indexOf("</", i);
+            while (close !== -1 && !isRawTextClose(html, close, name))
+                close = html.indexOf("</", close + 1);
+            i = close === -1 ? html.length : close + 2 + name.length;
             continue;
         }
         if (selfClosed || VOID_TAGS.has(name))
             continue;
         const peers = IMPLIED_CLOSE_PEERS[name];
         if (peers !== undefined) {
-            while (stack.length > 0 && peers.has(stack[stack.length - 1]))
+            while (stack.length > 0 && peers.has(presentLast(stack, "the top of the tag stack")))
                 stack.pop();
         }
         stack.push(name);
@@ -399,7 +399,7 @@ function htmlToMarkdown(body) {
     const article = new Readability(dom.document).parse();
     if (article?.content)
         return markdownConverter.turndown(article.content).trim();
-    return (dom.document.body?.textContent ?? "").trim();
+    return dom.document.body.textContent.trim();
 }
 /** Hostile HTML can throw inside the extraction stack; the body text, then the status union, catch the throw. A page that nests past the bound never reaches a parser, because the parse itself is the stall. */
 function htmlExtractionOf(body) {
@@ -413,7 +413,7 @@ function htmlExtractionOf(body) {
     catch {
         try {
             const dom = parseHTML(html);
-            return { kind: "text", text: (dom.document.body?.textContent ?? "").trim() };
+            return { kind: "text", text: dom.document.body.textContent.trim() };
         }
         catch {
             return { kind: "unextractable", detail: "the HTML extraction failed" };
@@ -436,7 +436,7 @@ async function extractBody(contentType, body) {
             return { kind: "text", text: result.text.trim(), pdfCut };
         }
         catch (error) {
-            return { kind: "unextractable", detail: `the PDF parser failed: ${error instanceof Error ? error.message : String(error)}` };
+            return { kind: "unextractable", detail: `the PDF parser failed: ${errorMessageOf(error) ?? textOf(error)}` };
         }
         finally {
             await parser.destroy();
@@ -449,13 +449,15 @@ async function extractBody(contentType, body) {
 }
 /** Build the ok result for one returned text, so the serialized-cap shrink rebuilds the same fields each round. */
 function okResultOf(base, fullText, kept, shown) {
-    return {
+    const result = {
         ...base,
-        ...(kept !== undefined ? { kept } : {}),
+        kept,
         text: shown,
         cut: shown.length < fullText.length,
-        ...(shown.length < fullText.length && kept === undefined ? { remainderNotKept: true } : {}),
     };
+    if (shown.length < fullText.length && kept === undefined)
+        result.remainderNotKept = true;
+    return result;
 }
 async function fetchOneUrl(rawUrl, deps, ctx) {
     let parsed;
@@ -465,11 +467,9 @@ async function fetchOneUrl(rawUrl, deps, ctx) {
     catch {
         return { status: "invalid_url", text: `web_fetch cannot read ${rawUrl}: it is not a valid URL.` };
     }
-    const approvedOrigins = new Set();
     const state = {
         lookup: deps.lookup ?? dnsLookup,
         hopRequest: deps.hopRequest ?? defaultHopRequest,
-        approvedOrigins,
         ctx,
     };
     let redirects = 0;
@@ -479,24 +479,14 @@ async function fetchOneUrl(rawUrl, deps, ctx) {
         }
         if (current.username !== "" || current.password !== "")
             current = withoutCredentials(current);
-        const origin = originOf(current);
         const literal = stripAddressBrackets(current.hostname);
-        if (isIP(literal) !== 0 && isGuardedAddress(literal) && !approvedOrigins.has(origin)) {
-            const asked = await askForOrigin(current, origin, ctx);
-            if (asked.kind === "denied")
-                return asked.output;
-            approvedOrigins.add(origin);
-        }
+        if (isIP(literal) !== 0 && isGuardedAddress(literal))
+            return refusedGuarded(current);
         const hop = await sendHop(current, state);
         if (hop.kind === "failed")
             return hop.output;
-        if (hop.kind === "guarded") {
-            const asked = await askForOrigin(current, origin, ctx);
-            if (asked.kind === "denied")
-                return asked.output;
-            approvedOrigins.add(origin);
-            continue;
-        }
+        if (hop.kind === "guarded")
+            return refusedGuarded(current);
         const response = hop.response;
         try {
             const status = response.statusCode ?? 0;
@@ -565,7 +555,7 @@ async function fetchOneUrl(rawUrl, deps, ctx) {
                     status: "unextractable",
                     contentType,
                     text: `web_fetch cannot extract text from the content type ${named}.`,
-                    ...(extracted.detail !== undefined ? { detail: extracted.detail } : {}),
+                    detail: extracted.detail,
                 };
             }
             const fullText = extracted.text.trim();
@@ -575,7 +565,7 @@ async function fetchOneUrl(rawUrl, deps, ctx) {
                 finalUrl: current.toString(),
                 contentType,
                 totalLength: fullText.length,
-                ...(extracted.pdfCut !== undefined ? { pdfCut: extracted.pdfCut } : {}),
+                pdfCut: extracted.pdfCut,
             };
             let output = okResultOf(base, fullText, undefined, shown);
             while (JSON.stringify(output).length > RESULT_BUDGET && shown.length > 0) {
@@ -593,20 +583,23 @@ async function fetchOneUrl(rawUrl, deps, ctx) {
                     ref,
                     toolName: "web_fetch",
                     toolCallId: ctx.invocationId,
-                    ...(ctx.session.scope.threadId !== undefined ? { threadId: ctx.session.scope.threadId } : {}),
+                    threadId: ctx.session.scope.threadId,
                     content,
                     totalLength: fullText.length,
                 });
                 if (put.isOk())
                     kept = { ref, keptLength: content.length };
             }
-            return okResultOf({ ...base, ...(kept !== undefined ? { kept } : {}) }, fullText, kept, shown);
+            return okResultOf(base, fullText, kept, shown);
         }
         finally {
             hop.dispose();
         }
     }
 }
+const WebFetchInputSchema = z.object({
+    url: z.string().min(1).max(2048).describe("The http or https URL of one page to read, for example a page a web_search result named."),
+});
 export function createWebFetchTool(deps = {}) {
     return defineTool({
         id: "web_fetch",
@@ -615,12 +608,10 @@ export function createWebFetchTool(deps = {}) {
             "The tool returns at most 30,000 characters; a longer text is cut, and the result carries a reference " +
             "through which `read_tool_output` reads the remainder when the harness kept it.\n" +
             "ABSENCE AND FAILURE ARE NORMAL: the statuses invalid_url (a URL the tool cannot parse), " +
-            "unsupported_scheme (a scheme that is not http or https), refused (a guarded address the user did not " +
-            "approve), http_error, redirect_limit, body_too_large, unextractable, and request_failed each name what " +
+            "unsupported_scheme (a scheme that is not http or https), refused (an internal address: loopback, " +
+            "private, link-local, or reserved), http_error, redirect_limit, body_too_large, unextractable, and request_failed each name what " +
             "happened. Report the status and continue, do not retry unchanged.",
-        inputSchema: z.object({
-            url: z.string().min(1).max(2048).describe("The http or https URL of one page to read, for example a page a web_search result named."),
-        }),
+        inputSchema: WebFetchInputSchema,
         describeCall: ({ url }) => url,
         execute: async ({ url }, ctx) => ok(await fetchOneUrl(url, deps, ctx)),
     });

package/dist/tools/research/web-search.d.ts

@@ -9,15 +9,17 @@
  * never as an error of the turn.
  */
 import { type Result } from "neverthrow";
-export interface WebSearchAnswer {
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
+export type WebSearchAnswer = {
     readonly answer?: string;
     readonly url?: string;
-}
-export interface WebSearchResult {
+};
+export type WebSearchResult = {
     readonly title: string;
     readonly url: string;
     readonly snippet?: string;
-}
+};
 export type WebSearchOutput = {
     readonly status: "ok";
     readonly answers: readonly WebSearchAnswer[];
@@ -39,11 +41,11 @@ export type WebSearchOutput = {
     readonly detail?: string;
 };
 /** One query with its terms already composed: the engine adds transport, not semantics. */
-export interface WebSearchRequest {
+export type WebSearchRequest = {
     /** The final query text, `site:` / `-site:` terms included. */
     readonly query: string;
     readonly recencyFilter?: "day" | "week" | "month" | "year";
-}
+};
 /** What one query returned: the mapped answers and the mapped result rows. */
 export type WebSearchPage = {
     readonly answers: readonly WebSearchAnswer[];
@@ -59,17 +61,24 @@ export type WebSearchEngineError = Exclude<WebSearchOutput, {
  * query terms and the optional recency filter, and resolves to the page or to
  * the error variant that names the failure.
  */
-export interface WebSearchEngine {
+export type WebSearchEngine = {
     search(request: WebSearchRequest): Promise<Result<WebSearchPage, WebSearchEngineError>>;
-}
-export interface WebSearchToolDeps {
+};
+export type WebSearchToolDeps = {
     /** The web-search engine the embedder injected. */
     readonly engine: WebSearchEngine;
-}
-export declare function createWebSearchTool(deps: WebSearchToolDeps): import("../define-tool.js").Tool<{
-    numResults: number;
-    query?: string | undefined;
-    queries?: string[] | undefined;
-    recencyFilter?: "year" | "day" | "week" | "month" | undefined;
-    domainFilter?: string | undefined;
-}, WebSearchOutput>;
+};
+declare const WebSearchInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    queries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    numResults: z.ZodDefault<z.ZodNumber>;
+    recencyFilter: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        month: "month";
+        week: "week";
+        year: "year";
+    }>>;
+    domainFilter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createWebSearchTool(deps: WebSearchToolDeps): Tool<z.infer<typeof WebSearchInputSchema>, WebSearchOutput>;
+export {};

package/dist/tools/research/web-search.js

@@ -50,6 +50,22 @@ function applyDomainFilter(results, filter) {
         return filter.include ? matches : !matches;
     });
 }
+const WebSearchInputSchema = z
+    .object({
+    query: z.string().min(1).optional().describe("One free-text search, for example a method name with its domain."),
+    queries: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(5)
+        .optional()
+        .describe("Up to 5 searches that run in one pass. Answers and results merge into one bounded list."),
+    numResults: z.number().int().min(1).max(20).default(5).describe("Maximum merged results (1–20, default 5)."),
+    recencyFilter: z.enum(["day", "week", "month", "year"]).optional().describe("Keep only results from this recency."),
+    domainFilter: z.string().optional().describe('One domain the search stays in, for example "nih.gov". A leading "-" excludes the domain instead.'),
+})
+    .refine((input) => (input.query !== undefined) !== (input.queries !== undefined), {
+    message: "Give exactly one of `query` or `queries`.",
+});
 export function createWebSearchTool(deps) {
     return defineTool({
         id: "web_search",
@@ -60,31 +76,20 @@ export function createWebSearchTool(deps) {
             "week, month, or year. Read one of the returned pages with `web_fetch`.\n" +
             "ABSENCE IS NORMAL: an empty results array means no page matched, and a status of http_error, retryable_status, " +
             "schema_mismatch, or not_json names a search that did not answer. Report either one and continue, do not retry unchanged.",
-        inputSchema: z
-            .object({
-            query: z.string().min(1).optional().describe("One free-text search, for example a method name with its domain."),
-            queries: z
-                .array(z.string().min(1))
-                .min(1)
-                .max(5)
-                .optional()
-                .describe("Up to 5 searches that run in one pass. Answers and results merge into one bounded list."),
-            numResults: z.number().int().min(1).max(20).default(5).describe("Maximum merged results (1–20, default 5)."),
-            recencyFilter: z.enum(["day", "week", "month", "year"]).optional().describe("Keep only results from this recency."),
-            domainFilter: z
-                .string()
-                .optional()
-                .describe('One domain the search stays in, for example "nih.gov". A leading "-" excludes the domain instead.'),
-        })
-            .refine((input) => (input.query !== undefined) !== (input.queries !== undefined), {
-            message: "Give exactly one of `query` or `queries`.",
-        }),
+        inputSchema: WebSearchInputSchema,
         describeCall: "none",
         execute: async ({ query, queries, numResults, recencyFilter, domainFilter }) => {
             const filter = parseDomainFilter(domainFilter);
             // The input refine guarantees exactly one of `query` and `queries`.
-            const queryList = queries ?? [query];
-            const requests = queryList.map((raw) => deps.engine.search({ query: queryTerms(raw, filter), ...(recencyFilter ? { recencyFilter } : {}) }));
+            let queryList;
+            if (queries !== undefined)
+                queryList = queries;
+            else {
+                if (query === undefined)
+                    throw new Error("search requires query");
+                queryList = [query];
+            }
+            const requests = queryList.map((raw) => deps.engine.search({ query: queryTerms(raw, filter), recencyFilter }));
             const responses = [];
             for (const response of await Promise.all(requests)) {
                 // An engine failure is the data-status variant the tool reports, not a turn error.

package/dist/tools/sandbox/link-packages.d.ts

@@ -14,22 +14,26 @@
  * the prompt layer.
  */
 import { type Result } from "neverthrow";
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
 import { type PackageQuery } from "../../sandbox/package-identity.js";
 import type { ExtendAnalysisFarm, PackageRequestOutcome } from "../../sandbox/types.js";
-export interface LinkPackagesDeps {
+export type LinkPackagesDeps = {
     readonly extendAnalysisFarm: ExtendAnalysisFarm;
     readonly analysisId: string;
-}
+};
 /** The tool result: one outcome per requested query, index-aligned. */
-export interface LinkPackagesResult {
+export type LinkPackagesResult = {
     readonly outcomes: readonly PackageRequestOutcome[];
-}
+};
 /**
  * Call the seam, and give the outcomes or the one reason that the call gave
  * no answer. An `err` and a rejected realization each give that reason, thus
  * no call site sees a throw.
  */
 export declare function callExtendAnalysisFarm(extendAnalysisFarm: ExtendAnalysisFarm, analysisId: string, queries: readonly PackageQuery[]): Promise<Result<readonly PackageRequestOutcome[], string>>;
-export declare function createLinkPackagesTool(deps: LinkPackagesDeps): import("../define-tool.js").Tool<{
-    packages: string[];
-}, LinkPackagesResult>;
+declare const LinkPackagesInputSchema: z.ZodObject<{
+    packages: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare function createLinkPackagesTool(deps: LinkPackagesDeps): Tool<z.infer<typeof LinkPackagesInputSchema>, LinkPackagesResult>;
+export {};

package/dist/tools/sandbox/link-packages.js

@@ -13,6 +13,8 @@
  * capability, thus the agent learns one grammar for the plan, the tool, and
  * the prompt layer.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { err, ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
@@ -44,9 +46,16 @@ export async function callExtendAnalysisFarm(extendAnalysisFarm, analysisId, que
         return (await extendAnalysisFarm(analysisId, queries)).mapErr((failure) => failure.reason);
     }
     catch (cause) {
-        return err(cause instanceof Error ? cause.message : String(cause));
+        return err(errorMessageOf(cause) ?? textOf(cause));
     }
 }
+const LinkPackagesInputSchema = z.object({
+    packages: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(50)
+        .describe('The packages to link into the farm, each as `[python:|r:]<name>[==<version>]`, for example ["scanpy", "r:Seurat", "numpy==1.26.4"]. A bare name searches both tracks.'),
+});
 export function createLinkPackagesTool(deps) {
     return defineTool({
         id: "link_packages",
@@ -60,13 +69,7 @@ export function createLinkPackagesTool(deps) {
             "or `unavailable` (the link pass itself could not answer — the `reason` says why; it says nothing about the package's presence, so report the reason and do not re-request packages). " +
             "After a `collision` of one name that BOTH tracks hold, call this tool again for that package with the prefixed form, `python:<name>` or `r:<name>`. " +
             "A collision is terminal only after that second call also refuses, or when it names two versions of one distribution — then report it and continue without the package.",
-        inputSchema: z.object({
-            packages: z
-                .array(z.string().min(1))
-                .min(1)
-                .max(50)
-                .describe('The packages to link into the farm, each as `[python:|r:]<name>[==<version>]`, for example ["scanpy", "r:Seurat", "numpy==1.26.4"]. A bare name searches both tracks.'),
-        }),
+        inputSchema: LinkPackagesInputSchema,
         describeCall: ({ packages }) => packages.join(", "),
         execute: async (input) => {
             // Every entry parses before any link lands. A partial link over a

package/dist/tools/sandbox/list-available-packages.d.ts

@@ -19,6 +19,8 @@
  * content hash where the source records them. A full listing carries no
  * hashes — a thousand rows of sha256 would bury the signal.
  */
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
 import type { EnvironmentStorePaths, PoolInventoryPackage, PoolInventorySection } from "../../config/environment-stores.js";
 import { type Track } from "../../sandbox/package-identity.js";
 import { type FarmLock } from "../../sandbox/farm.js";
@@ -100,12 +102,12 @@ export type PackagesResult = {
     readonly content: string;
 };
 /** The tool's input, as parsed from `inputSchema`. */
-export interface PackagesQuery {
+export type PackagesQuery = {
     readonly names?: readonly string[];
     readonly query?: string;
     readonly language?: "r" | "python" | "cli" | "node";
     readonly limit?: number;
-}
+};
 /**
  * Answer a packages query against a parsed catalog. Pure — the tool's `execute`
  * is only the file read plus this call.
@@ -150,9 +152,16 @@ export declare function readInventorySections(deps: ListAvailablePackagesDeps, a
  * host-readable farm `inflexa.lock` otherwise (a sandbox agent). The image
  * record merges into either report.
  */
-export declare function createListAvailablePackagesTool(deps?: ListAvailablePackagesDeps): import("../define-tool.js").Tool<{
-    names?: string[] | undefined;
-    query?: string | undefined;
-    language?: "r" | "python" | "node" | "cli" | undefined;
-    limit?: number | undefined;
-}, PackagesResult>;
+declare const ListAvailablePackagesInputSchema: z.ZodObject<{
+    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    query: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodEnum<{
+        cli: "cli";
+        node: "node";
+        python: "python";
+        r: "r";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createListAvailablePackagesTool(deps?: ListAvailablePackagesDeps): Tool<z.infer<typeof ListAvailablePackagesInputSchema>, PackagesResult>;
+export {};