@arnilo/prism 0.3.2 → 0.5.0

package/dist/testing/tool-conformance.js

@@ -7,7 +7,8 @@
 // Error; no test runner, no network. Execution is observed via the
 // tool_execution_started / tool_execution_blocked events the runtime emits,
 // not by mutating the caller's tool.
-import { dispatchToolCall } from "../tools.js";
+import { createActiveToolSet, createSearchToolsTool, createToolSearchState, HARD_MAX_TOOLS_INDEX, SEARCH_TOOLS_TOOL_NAME, selectDisclosedTools, } from "../tool-search.js";
+import { dispatchToolCall, filterTools } from "../tools.js";
 const denyAllPermission = { check: () => ({ allowed: false, reason: "denied" }) };
 const alwaysInvalidValidator = () => "invalid";
 /**
@@ -98,7 +99,133 @@ export async function dispatchAndCollect(probe) {
     });
     return { result, events };
 }
+/**
+ * Assert the tool-disclosure contract (plan 041) against the same narrowing the
+ * runtime applies: search mode only narrows (disclosed set is a subset of the
+ * allow/deny-filtered input, never wider, never zero, deterministic order); a
+ * denied tool is never described; the generated `search_tools` tool is always
+ * kept and its output is inert — names plus byte-truncated descriptions only,
+ * no JSON structure, no secret values — and activation stays disclosed beside
+ * the turn top-k next turn. Fails closed: an index over the hard cap discloses
+ * the full eligible list. Throws on the first violation.
+ */
+export function assertToolDisclosureConforms(options) {
+    const eligible = filterTools(options.tools, options.filter);
+    if (eligible.length === 0)
+        throw new Error("Disclosure conformance needs at least one eligible tool");
+    const activated = createActiveToolSet();
+    const topK = options.search?.topK ?? 16;
+    const state = createToolSearchState({ tools: eligible, activated, search: options.search });
+    const searchTool = createSearchToolsTool(state);
+    const runTools = [...eligible, searchTool];
+    const input = options.input ?? "zzzqqq unmatchable zero-match probe";
+    // 1. Narrowing stays a subset of the eligible list and always keeps search_tools.
+    const disclosed = selectDisclosedTools({ tools: runTools, input, search: options.search, activated });
+    const eligibleNames = new Set(eligible.map((tool) => tool.name));
+    eligibleNames.add(SEARCH_TOOLS_TOOL_NAME);
+    for (const tool of disclosed) {
+        if (!eligibleNames.has(tool.name)) {
+            throw new Error(`Disclosed tool ${tool.name} is not in the eligible list; search must never widen`);
+        }
+    }
+    if (!disclosed.some((tool) => tool.name === SEARCH_TOOLS_TOOL_NAME)) {
+        throw new Error("Disclosed set dropped the generated search_tools tool");
+    }
+    if (disclosed.length === 0)
+        throw new Error("Disclosure disclosed zero tools; fail closed to a bounded non-empty set");
+    // 2. A deny-listed tool is never described to the provider.
+    const deniedName = eligible[0].name;
+    const deniedDisclosed = selectDisclosedTools({
+        tools: filterTools(runTools, { deny: [deniedName] }),
+        input,
+        search: options.search,
+        activated,
+    });
+    if (deniedDisclosed.some((tool) => tool.name === deniedName)) {
+        throw new Error(`Denied tool ${deniedName} was described to the provider`);
+    }
+    // 3. Deterministic order for identical turns.
+    const again = selectDisclosedTools({ tools: runTools, input, search: options.search, activated });
+    if (JSON.stringify(again.map((tool) => tool.name)) !== JSON.stringify(disclosed.map((tool) => tool.name))) {
+        throw new Error("Disclosure order is not deterministic for identical turns");
+    }
+    // 4. Fail closed past the index hard cap: full eligible list, never zero, never wider.
+    const oversized = Array.from({ length: HARD_MAX_TOOLS_INDEX + 1 }, (_, index) => ({
+        name: `cap_${index}`,
+        description: "Fixture tool beyond the frozen index cap.",
+        parameters: { type: "object", properties: {} },
+        execute: () => ({ toolCallId: "x", name: "cap" }),
+    }));
+    const overflowed = selectDisclosedTools({ tools: oversized, input, search: options.search });
+    if (overflowed.length !== oversized.length) {
+        throw new Error(`Index overflow must disclose the full list; disclosed ${overflowed.length} of ${oversized.length}`);
+    }
+    // 5. search_tools output is inert: names + byte-truncated descriptions, no JSON
+    //    structure, no secret values; activation bounded to the eligible set.
+    const oversizedDescription = `${"padding ".repeat(160)}TAIL-MARKER-BEYOND-TRUNCATION`;
+    const probeEligible = [
+        ...eligible,
+        {
+            name: "oversized_desc_tool",
+            description: oversizedDescription,
+            parameters: { type: "object", properties: { untrusted: { type: "string" } } },
+            execute: () => ({ toolCallId: "x", name: "oversized_desc_tool" }),
+        },
+    ];
+    const probeState = createToolSearchState({ tools: probeEligible, activated, search: options.search });
+    const probeTool = createSearchToolsTool(probeState);
+    const probeResult = probeTool.execute({ query: "oversized_desc_tool" }, context("probe"));
+    if (probeResult.error)
+        throw new Error(`search_tools rejected a valid bounded query: ${probeResult.error.message}`);
+    const text = probeResult.content?.find((block) => block.type === "text");
+    if (text?.type !== "text" || !text.text.startsWith("- ")) {
+        throw new Error("search_tools returned no bounded name+description lines");
+    }
+    if (text.text.includes("TAIL-MARKER-BEYOND-TRUNCATION")) {
+        throw new Error("search_tools emitted an untruncated oversized description; descriptions are truncated, descriptions are never executed");
+    }
+    if (/[{}]/.test(text.text)) {
+        throw new Error("search_tools text carries JSON structure; output must be inert name+description lines only");
+    }
+    const activatedCount = activated.list().length;
+    if (activatedCount === 0 || activatedCount > topK)
+        throw new Error(`activation not bounded: ${activatedCount} names`);
+    const probeNames = new Set(probeEligible.map((tool) => tool.name));
+    for (const name of activated.list()) {
+        if (!probeNames.has(name))
+            throw new Error(`activated ${name} is not in the eligible set`);
+    }
+    // 5b. Secret scan: query every eligible tool by name; configured secret values
+    //     must never surface in model-facing search output even when a host
+    //     description carries one.
+    for (const tool of eligible) {
+        const probe = probeTool.execute({ query: tool.name }, context("probe-secret"));
+        const probeBlob = JSON.stringify(probe);
+        for (const secret of options.secrets ?? []) {
+            if (secret && probeBlob.includes(secret)) {
+                throw new Error("search output leaked a configured secret");
+            }
+        }
+    }
+    // 6. Activated tools stay disclosed on the next turn, beside the turn top-k.
+    //    (Names outside the runtime list are inert by design — e.g. the probe's
+    //    synthetic tool above — so only eligible names are asserted.)
+    const nextTurn = selectDisclosedTools({
+        tools: runTools,
+        input: "zzzqqq unmatchable next-turn probe",
+        search: options.search,
+        activated,
+    });
+    for (const name of activated.list()) {
+        if (eligibleNames.has(name) && !nextTurn.some((tool) => tool.name === name)) {
+            throw new Error(`activated tool ${name} was dropped from the next turn's disclosed set`);
+        }
+    }
+}
 function pickPolicy(options) {
     return { permission: options.permission, validate: options.validate, filter: options.filter };
 }
+function context(toolCallId) {
+    return { sessionId: "conformance", runId: "r", toolCallId };
+}
 //# sourceMappingURL=tool-conformance.js.map

package/dist/testing/tool-effect-store-conformance.d.ts

@@ -6,4 +6,3 @@ export interface ToolEffectStoreConformanceOptions {
 }
 /** Assert core claim/CAS, duplicate, reconciliation, and cleanup semantics without a test framework. */
 export declare function assertToolEffectStoreConforms(factory: () => ToolEffectStore | Promise<ToolEffectStore>, options?: ToolEffectStoreConformanceOptions): Promise<void>;
-export declare function runToolEffectStoreConformance(factory: () => ToolEffectStore | Promise<ToolEffectStore>, options?: ToolEffectStoreConformanceOptions): Promise<void>;

package/dist/testing/tool-effect-store-conformance.js

@@ -44,9 +44,6 @@ export async function assertToolEffectStoreConforms(factory, options = {}) {
     if (cleanup.deleted < 1)
         throw new Error("store cleanup must remove terminal effects");
 }
-export async function runToolEffectStoreConformance(factory, options = {}) {
-    await assertToolEffectStoreConforms(factory, options);
-}
 function key(identity, ownership, value, toolCallId = "call") {
     return {
         identity,

package/dist/thinking.d.ts

@@ -9,8 +9,16 @@ export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
  * Compat mapping families used by ≥2 packages, or explicit no-op for host-owned adapters.
  * Provider packages keep unique escape hatches (budgets, keep/all, tool_stream) local.
  */
-export type ThinkingCompatFamily = "openai_reasoning" | "reasoning_effort" | "thinking_type" | "noop";
+export type ThinkingCompatFamily = "openai_reasoning" | "reasoning_effort" | "thinking_type" | "google" | "output_config_effort" | "noop";
 export declare function isThinkingLevel(value: unknown): value is ThinkingLevel;
+/**
+ * Parse a host thinking-level value without guessing: known levels canonicalize to
+ * `ThinkingLevel`, unknown non-empty strings pass through as opaque `{ opaque }`
+ * (forward-compat passthrough), invalid/empty/non-string input fails closed.
+ */
+export declare function parseThinkingLevel(value: unknown): ThinkingLevel | {
+    readonly opaque: string;
+} | undefined;
 /**
  * Normalize a host thinkingLevel string. Known levels are lowercased; other non-empty
  * strings pass through as opaque effort values for forward-compatible provider fields.
@@ -26,17 +34,48 @@ export declare function thinkingCompatFor(family: ThinkingCompatFamily, level: T
  * Per-turn patches win over prior compat via {@link mergeProviderRequestOptions}.
  */
 export declare function applyThinkingLevel(options: ProviderRequestOptions | undefined, level: ThinkingLevel | string, family?: ThinkingCompatFamily): ProviderRequestOptions;
+/**
+ * Declared portable thinking levels for a model, if any (ascending ladder order).
+ * `undefined` means the provider declares no subset — forward-compat passthrough.
+ */
+export declare function thinkingLevelsForModel(model: Pick<ModelConfig, "provider" | "compat" | "capabilities">): readonly string[] | undefined;
+/**
+ * Strict declared-set membership (hosts fail closed on unknown levels).
+ * A model that declares no levels supports any value (forward-compat passthrough).
+ */
+export declare function isSupportedThinkingLevel(model: Pick<ModelConfig, "provider" | "compat" | "capabilities">, level: unknown): boolean;
+/**
+ * Snap a portable level to a model's declared set (design record §2):
+ * in-set → unchanged; below the declared minimum → up to the minimum
+ * (never silently disable what cannot be disabled); otherwise nearest declared
+ * level by ladder distance with ties breaking up; undeclared levels and
+ * undeclared sets pass through. Provider-documented snap tables
+ * (deepseek, Z.AI GLM-5.2, clinepass slots) override this generic fallback
+ * inside their own resolvers.
+ */
+export declare function snapThinkingLevel(model: Pick<ModelConfig, "provider" | "compat" | "capabilities">, level: ThinkingLevel | string): ThinkingLevel | string;
+/**
+ * Model-aware thinking-level application (design record §5). Resolves the family
+ * stamp-first (`compat.thinkingFamily` → inference → `capabilities.reasoning`),
+ * snaps the level to the model's declared set, and merges the compat patch
+ * per-turn-wins. Returns options unchanged for non-reasoning models — never
+ * invents a field where the model declares no thinking support.
+ */
+export declare function applyThinkingLevelForModel(options: ProviderRequestOptions | undefined, level: ThinkingLevel | string, model: Pick<ModelConfig, "provider" | "compat" | "capabilities">): ProviderRequestOptions;
 /**
  * Best-effort family inference from model metadata without a second options tree.
- * Prefer an explicit family in hosts/use-case workers when the provider is known.
+ * Prefer an explicit `compat.thinkingFamily` stamp in host/use-case workers when
+ * the provider is known; inference is the fallback (stamp-first).
  *
  * Heuristics (ordered):
- * 1. Existing `compat.thinking` object → `thinking_type`
- * 2. Existing `compat.reasoning` → `openai_reasoning`
- * 3. Existing `compat.reasoning_effort` → `reasoning_effort`
- * 4. Provider id starting with `openai` → `openai_reasoning`
- * 5. Provider id `neuralwatt` → `reasoning_effort`
- * 6. `capabilities.reasoning` → `reasoning_effort` (portable string field)
- * 7. Else `noop`
+ * 1. `compat.thinkingFamily` stamp → itself
+ * 2. Existing `compat.thinking` object → `thinking_type`
+ * 3. Existing `compat.thinkingConfig` object/boolean → `google`
+ * 4. Existing `compat.reasoning` → `openai_reasoning`
+ * 5. Existing `compat.reasoning_effort` → `reasoning_effort`
+ * 6. Provider id starting with `openai` → `openai_reasoning`
+ * 7. Provider id `neuralwatt` → `reasoning_effort`
+ * 8. `capabilities.reasoning` → `reasoning_effort` (portable string field)
+ * 9. Else `noop`
  */
 export declare function thinkingFamilyForModel(model: Pick<ModelConfig, "provider" | "compat" | "capabilities">): ThinkingCompatFamily;

package/dist/thinking.js

@@ -7,6 +7,40 @@ export const THINKING_LEVELS = ["none", "minimal", "low", "medium", "high", "xhi
 export function isThinkingLevel(value) {
     return typeof value === "string" && THINKING_LEVELS.includes(value);
 }
+const LEVEL_RANK = {
+    none: 0,
+    minimal: 1,
+    low: 2,
+    medium: 3,
+    high: 4,
+    xhigh: 5,
+    max: 6,
+};
+function isThinkingFamily(value) {
+    return (typeof value === "string" &&
+        (value === "openai_reasoning" ||
+            value === "reasoning_effort" ||
+            value === "thinking_type" ||
+            value === "google" ||
+            value === "output_config_effort" ||
+            value === "noop"));
+}
+function thinkingLevelRank(level) {
+    return isThinkingLevel(level) ? LEVEL_RANK[level] : undefined;
+}
+/**
+ * Parse a host thinking-level value without guessing: known levels canonicalize to
+ * `ThinkingLevel`, unknown non-empty strings pass through as opaque `{ opaque }`
+ * (forward-compat passthrough), invalid/empty/non-string input fails closed.
+ */
+export function parseThinkingLevel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = normalizeThinkingLevel(value);
+    if (!normalized)
+        return undefined;
+    return isThinkingLevel(normalized) ? normalized : { opaque: normalized };
+}
 /**
  * Normalize a host thinkingLevel string. Known levels are lowercased; other non-empty
  * strings pass through as opaque effort values for forward-compatible provider fields.
@@ -32,6 +66,10 @@ export function thinkingCompatFor(family, level) {
             return { reasoning_effort: normalized };
         case "thinking_type":
             return { thinking: { type: normalized === "none" ? "disabled" : "enabled" } };
+        case "google":
+            return { thinkingLevel: normalized };
+        case "output_config_effort":
+            return { output_config: { effort: normalized } };
         default: {
             const _exhaustive = family;
             return _exhaustive;
@@ -62,23 +100,111 @@ export function applyThinkingLevel(options, level, family = "reasoning_effort")
     }
     return mergeProviderRequestOptions(options, { compat: patch });
 }
+/**
+ * Declared portable thinking levels for a model, if any (ascending ladder order).
+ * `undefined` means the provider declares no subset — forward-compat passthrough.
+ */
+export function thinkingLevelsForModel(model) {
+    return model.capabilities?.thinkingLevels;
+}
+/**
+ * Strict declared-set membership (hosts fail closed on unknown levels).
+ * A model that declares no levels supports any value (forward-compat passthrough).
+ */
+export function isSupportedThinkingLevel(model, level) {
+    const parsed = parseThinkingLevel(level);
+    if (!parsed)
+        return false;
+    const declared = thinkingLevelsForModel(model);
+    if (!declared || declared.length === 0)
+        return true;
+    const value = typeof parsed === "string" ? parsed : parsed.opaque;
+    return declared.includes(value);
+}
+/**
+ * Snap a portable level to a model's declared set (design record §2):
+ * in-set → unchanged; below the declared minimum → up to the minimum
+ * (never silently disable what cannot be disabled); otherwise nearest declared
+ * level by ladder distance with ties breaking up; undeclared levels and
+ * undeclared sets pass through. Provider-documented snap tables
+ * (deepseek, Z.AI GLM-5.2, clinepass slots) override this generic fallback
+ * inside their own resolvers.
+ */
+export function snapThinkingLevel(model, level) {
+    const normalized = normalizeThinkingLevel(String(level));
+    if (!normalized)
+        return String(level);
+    const declared = thinkingLevelsForModel(model);
+    if (!declared || declared.length === 0)
+        return normalized;
+    if (declared.includes(normalized))
+        return normalized;
+    const rank = thinkingLevelRank(normalized);
+    const ranked = declared
+        .map((entry) => ({ entry, rank: thinkingLevelRank(entry) }))
+        .filter((entry) => entry.rank != null);
+    if (rank == null || ranked.length === 0)
+        return normalized;
+    const minRank = Math.min(...ranked.map(({ rank: r }) => r));
+    if (rank < minRank)
+        return ranked.find(({ rank: r }) => r === minRank).entry;
+    let best = ranked[0].entry;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    let bestRank = Number.NEGATIVE_INFINITY;
+    for (const { entry, rank: candidateRank } of ranked) {
+        const distance = Math.abs(candidateRank - rank);
+        if (distance < bestDistance || (distance === bestDistance && candidateRank > bestRank)) {
+            best = entry;
+            bestDistance = distance;
+            bestRank = candidateRank;
+        }
+    }
+    return best;
+}
+/**
+ * Model-aware thinking-level application (design record §5). Resolves the family
+ * stamp-first (`compat.thinkingFamily` → inference → `capabilities.reasoning`),
+ * snaps the level to the model's declared set, and merges the compat patch
+ * per-turn-wins. Returns options unchanged for non-reasoning models — never
+ * invents a field where the model declares no thinking support.
+ */
+export function applyThinkingLevelForModel(options, level, model) {
+    const normalized = normalizeThinkingLevel(String(level));
+    if (!normalized)
+        return options ?? {};
+    const family = model.compat?.thinkingFamily != null && isThinkingFamily(model.compat.thinkingFamily)
+        ? model.compat.thinkingFamily
+        : thinkingFamilyForModel(model);
+    if (family === "noop")
+        return options ?? {};
+    return applyThinkingLevel(options, snapThinkingLevel(model, normalized), family);
+}
 /**
  * Best-effort family inference from model metadata without a second options tree.
- * Prefer an explicit family in hosts/use-case workers when the provider is known.
+ * Prefer an explicit `compat.thinkingFamily` stamp in host/use-case workers when
+ * the provider is known; inference is the fallback (stamp-first).
  *
  * Heuristics (ordered):
- * 1. Existing `compat.thinking` object → `thinking_type`
- * 2. Existing `compat.reasoning` → `openai_reasoning`
- * 3. Existing `compat.reasoning_effort` → `reasoning_effort`
- * 4. Provider id starting with `openai` → `openai_reasoning`
- * 5. Provider id `neuralwatt` → `reasoning_effort`
- * 6. `capabilities.reasoning` → `reasoning_effort` (portable string field)
- * 7. Else `noop`
+ * 1. `compat.thinkingFamily` stamp → itself
+ * 2. Existing `compat.thinking` object → `thinking_type`
+ * 3. Existing `compat.thinkingConfig` object/boolean → `google`
+ * 4. Existing `compat.reasoning` → `openai_reasoning`
+ * 5. Existing `compat.reasoning_effort` → `reasoning_effort`
+ * 6. Provider id starting with `openai` → `openai_reasoning`
+ * 7. Provider id `neuralwatt` → `reasoning_effort`
+ * 8. `capabilities.reasoning` → `reasoning_effort` (portable string field)
+ * 9. Else `noop`
  */
 export function thinkingFamilyForModel(model) {
+    const stamp = model.compat?.thinkingFamily;
+    if (isThinkingFamily(stamp))
+        return stamp;
     const compat = model.compat ?? {};
     if (compat.thinking != null && typeof compat.thinking === "object")
         return "thinking_type";
+    if (compat.thinkingConfig != null && (typeof compat.thinkingConfig === "object" || typeof compat.thinkingConfig === "boolean")) {
+        return "google";
+    }
     if (compat.reasoning != null)
         return "openai_reasoning";
     if (compat.reasoning_effort != null)

package/dist/tool-search.d.ts

@@ -0,0 +1,76 @@
+import type { Message, ToolDefinition } from "./contracts.js";
+/** Same shape as `AgentInput`; kept structural here so core's assembler and this module never form a runtime cycle. */
+type ToolSearchInput = string | Message | readonly Message[];
+export type ToolsDisclosure = "all" | "search";
+export interface ToolsSearchOptions {
+    /** Top-k tools disclosed per turn. Default 16; clamped to the hard cap. */
+    readonly topK?: number;
+}
+export declare const SEARCH_TOOLS_TOOL_NAME = "search_tools";
+export declare const DEFAULT_TOOLS_SEARCH_TOP_K = 16;
+export declare const HARD_MAX_TOOLS_SEARCH_TOP_K = 64;
+/** Frozen index cap; larger registries fail closed to full disclosure. */
+export declare const HARD_MAX_TOOLS_INDEX = 1024;
+export declare const DEFAULT_MAX_TOOLS_SEARCH_QUERY_BYTES = 4096;
+export declare const HARD_MAX_TOOLS_SEARCH_QUERY_BYTES = 65536;
+export declare const TOOL_DISCLOSURE_ERROR_CODE: "tool_disclosure_exceeded";
+export declare class ToolDisclosureError extends Error {
+    readonly code: "tool_disclosure_exceeded";
+    constructor(message: string);
+}
+export declare function isToolDisclosureError(error: unknown): error is ToolDisclosureError;
+/** Run options win over agent config (mirrors resolveSkillsDisclosure); default "all". */
+export declare function resolveToolsDisclosure(run?: ToolsDisclosure, agent?: ToolsDisclosure): ToolsDisclosure;
+/** Activation set: same shape as LoadedSkillSet (names-only persistence, per-session instance). */
+export interface ActiveToolSet {
+    has(name: string): boolean;
+    add(name: string): void;
+    list(): readonly string[];
+    clear(): void;
+}
+export declare function createActiveToolSet(): ActiveToolSet;
+interface PostingEntry {
+    readonly toolIndex: number;
+    tf: number;
+}
+export interface ToolSearchIndex {
+    readonly tools: readonly ToolDefinition[];
+    readonly postings: ReadonlyMap<string, PostingEntry[]>;
+}
+/** ponytail: O(n·d) lexical index, rebuilt on registry change by the caller — embedder-backed
+ *  scoring via the @arnilo/prism-memory/rag seam if accuracy fixtures fall short (plan 041). */
+export declare function createToolSearchIndex(tools: readonly ToolDefinition[], skip?: (tool: ToolDefinition) => boolean): ToolSearchIndex;
+export interface ToolSearchMatch {
+    readonly name: string;
+    readonly description?: string;
+    /** Query terms present in name/description, most significant first. */
+    readonly matched: readonly string[];
+}
+/** Bounded lexical scoring: BM25-lite (tf × IDF, registry-derived DF). Ties keep registry order. */
+export declare function scoreTools(index: ToolSearchIndex, query: string, k: number, queryByteCap?: number): readonly ToolSearchMatch[];
+export interface ToolSearchState {
+    readonly index: ToolSearchIndex;
+    readonly activated: ActiveToolSet;
+    readonly topK: number;
+}
+export declare function createToolSearchState(options: {
+    readonly tools: readonly ToolDefinition[];
+    readonly activated: ActiveToolSet;
+    readonly search?: ToolsSearchOptions;
+}): ToolSearchState;
+/** Provider-facing narrowing: activated tools ∪ top-k for the turn. Fails closed — any
+ *  scoring/index error discloses the full input list (never zero, never wider than input). */
+export declare function selectDisclosedTools(options: {
+    readonly tools: readonly ToolDefinition[];
+    readonly input: ToolSearchInput;
+    readonly queryByteCap?: number;
+    readonly search?: ToolsSearchOptions;
+    readonly activated?: {
+        has(name: string): boolean;
+    };
+}): readonly ToolDefinition[];
+/** Model-facing activation tool, generated only in search mode. Results are inert
+ *  name+description lines — no schemas or bodies — and activation re-checks allow/deny
+ *  at dispatch time (blocked-reason matrix unchanged). */
+export declare function createSearchToolsTool(state: ToolSearchState, queryByteCap?: number): ToolDefinition;
+export {};