agentfootprint 10.3.0 → 10.4.0

package/dist/types/tool-lint/cli.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Tool-lint CLI core (RFC-002 block C3 — the CI gate).
+ *
+ * Pattern: humble shell — `bin/agentfootprint-lint-tools.mjs` is a
+ *          3-line wrapper; ALL behavior (arg parsing, catalog coercion,
+ *          report, exit code) lives here so it is unit-testable without
+ *          spawning a process.
+ * Role:    `src/tool-lint/`. Reads ONE JSON file of tools, prints a
+ *          report, returns the process exit code:
+ *            0 — report.ok
+ *            1 — findings failed the gate (!ok)
+ *            2 — usage / input error (bad flags, unreadable file,
+ *                unrecognized JSON shape)
+ *
+ * ## Embedder & gating honesty
+ *
+ * The CLI has no way to receive a consumer embedder, so it uses the
+ * built-in deterministic mock (char-frequency, offline, dependency-free)
+ * for the similarity RANKING — and, by default, does NOT gate on it:
+ * without `--threshold`, similarity is report-only (relative ordering +
+ * watch hints) and the exit code reflects structural findings alone.
+ * Pass `--threshold` to make confusable pairs fail the gate — you own
+ * the calibration at that point (start from
+ * `MOCK_EMBEDDER_CALIBRATION.confusabilityThreshold` = 0.94). For real
+ * embedder gating, use `analyzeToolCatalog` from
+ * `agentfootprint/observe` in a small script instead.
+ */
+import type { CatalogTool } from './types.js';
+export interface ToolLintCliIO {
+    readonly stdout: (line: string) => void;
+    readonly stderr: (line: string) => void;
+}
+/**
+ * Normalize any of the recognized tool-list JSON shapes to the lint's
+ * plain catalog. Throws (with a shape description) on unrecognized
+ * input — the CLI maps that to exit code 2.
+ */
+export declare function coerceCatalog(json: unknown): readonly CatalogTool[];
+/**
+ * Run the lint CLI. Returns the exit code (never calls `process.exit` —
+ * the bin wrapper assigns it to `process.exitCode`).
+ */
+export declare function runToolLintCli(argv: readonly string[], io?: ToolLintCliIO): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/tool-lint/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/tool-lint/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAqBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,WAAW,EAAE,CAuCnE;AAmDD;;;GAGG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,GAAE,aAKH,GACA,OAAO,CAAC,MAAM,CAAC,CAwDjB"}

package/dist/types/tool-lint/format.d.ts

@@ -0,0 +1,19 @@
+/**
+ * formatToolCatalogReport — human-readable rendering of a lint report.
+ *
+ * Pattern: pure presenter. One report → one string; used verbatim by the
+ *          CLI (`agentfootprint-lint-tools`) and the examples so output
+ *          stays byte-identical across surfaces.
+ * Role:    `src/tool-lint/` leaf. No I/O.
+ */
+import type { ToolCatalogReport } from './types.js';
+export interface FormatReportOptions {
+    /** How many ranked pairs to show in the relative-ordering section.
+     *  Default 10. 0 hides the section. */
+    readonly topPairs?: number;
+    /** How many WATCH pairs to print before eliding the rest (the report
+     *  object always carries all of them). Default 10. */
+    readonly maxWatch?: number;
+}
+export declare function formatToolCatalogReport(report: ToolCatalogReport, options?: FormatReportOptions): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/types/tool-lint/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/tool-lint/format.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC;2CACuC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;0DACsD;IACtD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,mBAAwB,GAChC,MAAM,CA6DR"}

package/dist/types/tool-lint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tool-lint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,YAAY,EACV,yBAAyB,EACzB,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,+BAA+B,EAC/B,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,GAChC,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEhF,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/tool-lint/rules.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Structural lint rules (RFC-002 block C2) — the PLUGGABLE RULE PACK.
+ *
+ * Pattern: Strategy list — each rule is a plain `{ id, check }` object;
+ *          `defaultStructuralRules` is OUR pack, and consumers add /
+ *          remove / replace freely via `AnalyzeToolCatalogOptions.rules`.
+ *          Parameterizable rules ship as FACTORIES (`descriptionRule`,
+ *          `saysWhatNotWhenRule`, …) returning a configured `LintRule`.
+ * Role:    `src/tool-lint/` leaf. Pure functions over `CatalogTool`;
+ *          no embedder, no I/O.
+ *
+ * Every rule encodes a FIELD FINDING from real catalogs (the Neo SAN
+ * triage agent's 29-tool catalog was the seed corpus):
+ *
+ *   1. description-missing-or-short — the model can only guess from a name.
+ *   2. says-what-not-when — describes WHAT the tool returns but gives the
+ *      model no cue for WHEN to pick it over a sibling (the #1 cause of
+ *      twin-tool confusion: 'get_fcns_database' vs 'influx_get_fcns_database').
+ *   3. enum-in-prose — string params whose legal values are listed in prose
+ *      ("avg_iops | peak_iops | mbps") instead of a JSON-Schema `enum` the
+ *      model (and validators, see #9 tool-args validation) can act on.
+ *   4. optional-param-undocumented — optional params whose omission has
+ *      meaning (fabric-wide sweep vs one switch) but whose schema never
+ *      says so; the model can't reason about leaving them out.
+ *
+ * Honest claim: these are token/regex HEURISTICS. They flag review
+ * prompts, not certainties — expect (rare) false positives and tune via
+ * the factory options instead of deleting the rule.
+ */
+import type { LintRule } from './types.js';
+export interface DescriptionRuleOptions {
+    /** Descriptions shorter than this (in chars) get a `warn`. Default 40. */
+    readonly minChars?: number;
+}
+/**
+ * Missing description → `error` (the model can only guess from the
+ * name). Present but shorter than `minChars` → `warn` (too short to
+ * differentiate from siblings).
+ */
+export declare function descriptionRule(options?: DescriptionRuleOptions): LintRule;
+/** RFC-002 C2 heuristic cue list — temporal/conditional words whose
+ *  presence suggests the description says WHEN to use the tool. */
+export declare const DEFAULT_WHEN_CUES: readonly string[];
+export interface SaysWhatNotWhenRuleOptions {
+    /** Cue tokens (whole-word, case-insensitive). Default `DEFAULT_WHEN_CUES`. */
+    readonly cueTokens?: readonly string[];
+}
+/**
+ * A description with NO temporal/conditional cue token usually describes
+ * WHAT the tool returns but never WHEN to pick it — the #1 cause of
+ * twin-tool confusion. Heuristic by design: tune `cueTokens` rather than
+ * dropping the rule. Skips tools with no description (rule 1's finding).
+ */
+export declare function saysWhatNotWhenRule(options?: SaysWhatNotWhenRuleOptions): LintRule;
+/**
+ * A string param whose description enumerates its legal values in prose
+ * (pipe-separated literals, or comma lists behind "one of"/"allowed
+ * values") should declare a JSON-Schema `enum` instead — the model picks
+ * reliably from enums, and arg validators (#9) can enforce them. The
+ * field case: Neo's `influx_get_port_ranking.metric` =
+ * `"avg_iops | peak_iops | mbps"`.
+ */
+export declare function enumInProseRule(): LintRule;
+/** Words that signal the description DOES say what omission means. */
+export declare const DEFAULT_OMISSION_CUES: readonly string[];
+export interface OptionalParamRuleOptions {
+    /** Cue tokens that satisfy the rule. Default `DEFAULT_OMISSION_CUES`. */
+    readonly omissionCues?: readonly string[];
+}
+/**
+ * An optional param's omission usually MEANS something (Neo:
+ * `influx_get_interface_counters` without `switch_name` = fabric-wide
+ * sweep) — but the model can only reason about leaving a param out if
+ * the description says so. No description at all, or one with no
+ * omission cue, gets a `warn`.
+ */
+export declare function optionalParamRule(options?: OptionalParamRuleOptions): LintRule;
+/**
+ * OUR rule pack, built with default options. Compose your own:
+ *
+ *   rules: [...defaultStructuralRules, myRule]                 // add
+ *   rules: defaultStructuralRules.filter(r => r.id !== '…')    // remove
+ *   rules: [descriptionRule({ minChars: 80 }), …]              // re-tune
+ */
+export declare const defaultStructuralRules: readonly LintRule[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/types/tool-lint/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/tool-lint/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAe,QAAQ,EAAqB,MAAM,YAAY,CAAC;AA2C3E,MAAM,WAAW,sBAAsB;IACrC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,QAAQ,CA6B9E;AAID;mEACmE;AACnE,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAO9C,CAAC;AAEF,MAAM,WAAW,0BAA0B;IACzC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B,GAAG,QAAQ,CAqBtF;AAcD;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,QAAQ,CA4B1C;AAgBD,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAalD,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,yEAAyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,QAAQ,CA+BlF;AAID;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,QAAQ,EAKrD,CAAC"}

package/dist/types/tool-lint/types.d.ts

@@ -0,0 +1,156 @@
+/**
+ * tool-lint types — the tool-catalog confusability lint contract
+ * (RFC-002 tier 1, blocks C1–C3).
+ *
+ * Pattern: Strategy seam (the plug-and-play meta-pattern) — the frame
+ *          and rule engine are the library's; the embedder, thresholds,
+ *          and structural rule pack are all consumer-injected, with our
+ *          defaults. Exactly like NarrativeFormatter / reliability /
+ *          permission / commentary strategies.
+ * Role:    `src/tool-lint/` leaf module. ZERO stack buy-in: input is a plain
+ *          `{ name, description?, inputSchema? }[]` — any OpenAI /
+ *          Anthropic / LangChain / MCP tool list normalizes to it
+ *          (see `coerceCatalog`). The library's own `Tool[]` adapts via
+ *          `catalogFromTools`.
+ *
+ * ## Honest claim (RFC-002 §2)
+ *
+ * Confusability here is embedding geometry over what the model READS
+ * (tool name + description) — a deterministic heuristic for "could the
+ * model mix these up", never a measurement of any model's actual
+ * selection function. Tier 3 (choice-entropy sampling) validates the
+ * proxy; until then treat verdicts as review prompts, not ground truth.
+ */
+import type { Embedder, SimilarityPair } from '../influence-core/index.js';
+/**
+ * One tool as the lint sees it — the minimal, framework-agnostic shape.
+ * `inputSchema` is a JSON Schema object (the same one the LLM sees);
+ * structural rules read `properties` / `required` / `enum` from it.
+ */
+export interface CatalogTool {
+    readonly name: string;
+    readonly description?: string;
+    /** JSON Schema for the tool's arguments (`type: 'object'` shape). */
+    readonly inputSchema?: Readonly<Record<string, unknown>>;
+}
+/** Verdict for one description pair from the similarity analysis. */
+export type PairVerdict = 'confusable' | 'watch';
+/** One flagged pair: two tools the model could plausibly mix up. */
+export interface ConfusablePairFinding {
+    readonly kind: PairVerdict;
+    /** Tool names (input order: `a` has the lower catalog index). */
+    readonly a: string;
+    readonly b: string;
+    /** cosine(embed(a), embed(b)) over `confusabilityText` of each tool. */
+    readonly similarity: number;
+    /**
+     * Heuristic suggestion for the DIFFERENTIATING AXIS — what to make
+     * explicit in the descriptions so the model can tell them apart
+     * (e.g. "names differ only by 'influx' — say WHEN to use each").
+     */
+    readonly hint: string;
+}
+/** Severity of a structural finding. `error` fails the gate by default. */
+export type LintSeverity = 'error' | 'warn';
+/** One structural finding from a `LintRule`. */
+export interface StructuralFinding {
+    /** Id of the rule that produced this finding. */
+    readonly rule: string;
+    /** Name of the offending tool. */
+    readonly tool: string;
+    readonly severity: LintSeverity;
+    readonly message: string;
+    /** Offending parameter name, when the finding is param-scoped. */
+    readonly param?: string;
+    /** Concrete fix suggestion (e.g. the JSON-Schema `enum` to add). */
+    readonly suggestion?: string;
+}
+/**
+ * One pluggable structural rule. Rules are plain objects — add your own
+ * to `rules` in `analyzeToolCatalog` options, or filter the exported
+ * `defaultStructuralRules` to remove ours.
+ */
+export interface LintRule {
+    /** Stable id, kebab-case (shows on findings + CLI output). */
+    readonly id: string;
+    /** Inspect ONE tool (with the whole catalog for context) and return
+     *  zero or more findings. Must not throw on weird-but-valid input. */
+    check(tool: CatalogTool, catalog: readonly CatalogTool[]): readonly StructuralFinding[];
+}
+export interface AnalyzeToolCatalogOptions {
+    /**
+     * Injected embedder for the confusability analysis. OMITTED → the
+     * similarity analysis is skipped (structural rules still run) and
+     * `report.similarity.analyzed` is false.
+     *
+     * Wrap in an `EmbeddingCache` (from `agentfootprint/observe`) so
+     * catalog descriptions embed once across lint runs — keyed by content
+     * hash, so unchanged descriptions cost nothing on re-lint.
+     */
+    readonly embedder?: Embedder;
+    /**
+     * Pairs with similarity ≥ this are `confusable`. Default 0.85 — a
+     * STARTING point calibrated for real sentence embedders (where
+     * unrelated tool descriptions typically land 0.3–0.7).
+     *
+     * ⚠ Per-embedder calibration is REQUIRED (RFC-002 §3): absolute
+     * cosine ranges differ by embedder. The test/demo `mockEmbedder`
+     * (character-frequency) compresses unrelated prose into ~0.85–0.97,
+     * so with the mock use `MOCK_EMBEDDER_CALIBRATION` and trust only
+     * RELATIVE ordering of pairs, never absolute verdicts.
+     */
+    readonly confusabilityThreshold?: number;
+    /**
+     * Pairs within this band BELOW the threshold are `watch` (advisory —
+     * never fail the gate). Default 0.05.
+     */
+    readonly watchBand?: number;
+    /**
+     * The structural rule pack. Default `defaultStructuralRules`.
+     * Add/remove freely — rules are plain `{ id, check }` objects.
+     */
+    readonly rules?: readonly LintRule[];
+    /**
+     * Which structural severity fails the gate (`report.ok`).
+     * Default 'error' — warnings are advisory. 'warn' = strict mode.
+     */
+    readonly failOn?: LintSeverity;
+    /** Abort signal threaded to the embedder (network backends). */
+    readonly signal?: AbortSignal;
+}
+/** The similarity section of a report. */
+export interface SimilarityReport {
+    /** False when no embedder was supplied — similarity was skipped. */
+    readonly analyzed: boolean;
+    readonly confusable: readonly ConfusablePairFinding[];
+    readonly watch: readonly ConfusablePairFinding[];
+    /**
+     * EVERY pair ranked by similarity, descending — the relative-ordering
+     * view that stays meaningful under ANY embedder (including the mock).
+     * Empty when `analyzed` is false.
+     */
+    readonly ranked: readonly SimilarityPair[];
+    readonly thresholds: {
+        readonly confusabilityThreshold: number;
+        readonly watchBand: number;
+    };
+}
+/** The lint report — `ok` is the CI-gateable verdict. */
+export interface ToolCatalogReport {
+    /**
+     * True when there are no confusable pairs AND no structural findings
+     * at/above `failOn` severity. The CI gate: exit non-zero on `!ok`.
+     */
+    readonly ok: boolean;
+    readonly toolCount: number;
+    readonly similarity: SimilarityReport;
+    readonly structural: readonly StructuralFinding[];
+    readonly summary: {
+        readonly confusable: number;
+        readonly watch: number;
+        readonly errors: number;
+        readonly warnings: number;
+    };
+}
+export type { Embedder, SimilarityPair };
+//# sourceMappingURL=types.d.ts.map

package/dist/types/tool-lint/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tool-lint/types.ts"],"names":[],"mappings":"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"}

package/dist/types/tool-providers/gatedTools.d.ts

@@ -32,6 +32,6 @@
  *       : alwaysVisible.includes(toolName),
  *   );
  */
-import type { ToolProvider, ToolGatePredicate } from './types.js';
+import type { ToolProvider, ToolGatePredicate } from '../tools/toolProvider.js';
 export declare function gatedTools(inner: ToolProvider, predicate: ToolGatePredicate): ToolProvider;
 //# sourceMappingURL=gatedTools.d.ts.map

package/dist/types/tool-providers/gatedTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gatedTools.d.ts","sourceRoot":"","sources":["../../../src/tool-providers/gatedTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAuB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAUvF,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,iBAAiB,GAAG,YAAY,CAmB1F"}
+{"version":3,"file":"gatedTools.d.ts","sourceRoot":"","sources":["../../../src/tool-providers/gatedTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EACV,YAAY,EAEZ,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAUlC,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,iBAAiB,GAAG,YAAY,CAmB1F"}

package/dist/types/tool-providers/index.d.ts

@@ -49,10 +49,15 @@
  */
 export { staticTools } from './staticTools.js';
 export { gatedTools } from './gatedTools.js';
-export { skillScopedTools, skillScopedToolsTarget, SKILL_SCOPED_TOOLS_ID_PREFIX, } from './skillScopedTools.js';
-export type { ToolProvider, ToolDispatchContext, ToolGatePredicate } from './types.js';
-export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, MCP_TOOL_EXTRAS_KEY, retryingFetch, } from '../lib/mcp/index.js';
+export { skillScopedTools, skillScopedToolsTarget, SKILL_SCOPED_TOOLS_ID_PREFIX, } from '../tools/skillScopedTools.js';
+export type { ToolProvider, ToolDispatchContext, ToolGatePredicate, } from '../tools/toolProvider.js';
+export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, MCP_TOOL_EXTRAS_KEY, retryingFetch, } from '../mcp/index.js';
 export { agentCoreGatewayTransport, agentCoreGatewayUrl, gatewaySearchTool, hasGatewaySearch, AGENTCORE_GATEWAY_SEARCH_TOOL, AGENTCORE_POLICY_SESSION_HEADER, AGENTCORE_SIGV4_SERVICE, } from '../adapters/mcp/agentcore.js';
 export type { AgentCoreGatewayTransportOptions, AgentCoreGatewayUrlOptions, } from '../adapters/mcp/agentcore.js';
-export type { GatewayTransportOptions, McpCallToolResult, McpClient, McpClientOptions, McpConnection, McpConnectionOptions, McpSdk, McpSdkClient, ThrottleFetch, McpTransport, McpStdioTransport, McpHttpTransport, McpGatewayTransport, MockMcpClientOptions, MockMcpTool, McpServeOptions, McpServeHandle, McpServeTransport, McpStdioServeTransport, McpHttpServeTransport, McpSdkServer, McpToolExtras, } from '../lib/mcp/index.js';
+export { agentCoreRuntimeMcpTransport, agentCoreRuntimeUrl, } from '../adapters/mcp/agentcoreRuntime/transport.js';
+export { AGENTCORE_RUNTIME_SESSION_HEADER } from '../adapters/mcp/agentcoreRuntime/session.js';
+export type { AgentCoreRuntimeAuth, AgentCoreRuntimeBearerAuth, AgentCoreRuntimeMcpTransportOptions, AgentCoreRuntimeRetryOptions, AgentCoreRuntimeUrlOptions, } from '../adapters/mcp/agentcoreRuntime/transport.js';
+export type { AgentCoreRuntimeSession } from '../adapters/mcp/agentcoreRuntime/session.js';
+export type { AgentCoreRuntimeSdkClient, BedrockAgentCoreRuntimeSdkModule, } from '../adapters/mcp/agentcoreRuntime/invoke.js';
+export type { GatewayTransportOptions, McpCallToolResult, McpClient, McpClientOptions, McpConnection, McpConnectionOptions, McpSdk, McpSdkClient, ThrottleFetch, McpTransport, McpStdioTransport, McpHttpTransport, McpGatewayTransport, MockMcpClientOptions, MockMcpTool, McpServeOptions, McpServeHandle, McpServeTransport, McpStdioServeTransport, McpHttpServeTransport, McpSdkServer, McpToolExtras, } from '../mcp/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/tool-providers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tool-providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,gBAAgB,EAGhB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKvF,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC,EAIjC,mBAAmB,EAKnB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAIhB,aAAa,EACb,oBAAoB,EACpB,MAAM,EACN,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,YAAY,EACZ,aAAa,GACd,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tool-providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,gBAAgB,EAGhB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC,EAIjC,mBAAmB,EAKnB,aAAa,GACd,MAAM,iBAAiB,CAAC;AAKzB,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,GACpB,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAC/F,YAAY,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,mCAAmC,EACnC,4BAA4B,EAC5B,0BAA0B,GAC3B,MAAM,+CAA+C,CAAC;AACvD,YAAY,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AAC3F,YAAY,EACV,yBAAyB,EACzB,gCAAgC,GACjC,MAAM,4CAA4C,CAAC;AACpD,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAIhB,aAAa,EACb,oBAAoB,EACpB,MAAM,EACN,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,YAAY,EACZ,aAAa,GACd,MAAM,iBAAiB,CAAC"}

package/dist/types/tool-providers/staticTools.d.ts

@@ -16,7 +16,7 @@
  *   const visible = provider.list({ iteration: 0, identity: { conversationId: '_' } });
  *   const agent = Agent.create({ provider: llm, model }).tools(visible).build();
  */
-import type { Tool } from '../core/tools.js';
-import type { ToolProvider } from './types.js';
+import type { Tool } from '../tools/tools.js';
+import type { ToolProvider } from '../tools/toolProvider.js';
 export declare function staticTools(tools: readonly Tool[]): ToolProvider;
 //# sourceMappingURL=staticTools.d.ts.map

package/dist/types/tool-providers/staticTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staticTools.d.ts","sourceRoot":"","sources":["../../../src/tool-providers/staticTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,YAAY,CAAC;AAGpE,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,YAAY,CAWhE"}
+{"version":3,"file":"staticTools.d.ts","sourceRoot":"","sources":["../../../src/tool-providers/staticTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AAGlF,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,YAAY,CAWhE"}

package/dist/types/tools/askComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"askComponent.d.ts","sourceRoot":"","sources":["../../../src/tools/askComponent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;CACjC;AAED,wDAAwD;AACxD,MAAM,MAAM,yBAAyB,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEhF;;;;;;;;;;;GAWG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,8BAAwC;IACrD,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C;gDAC4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC;gBAEf,MAAM,EAAE,yBAAyB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW;CAO/F;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAwC9F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAe7E"}