@infinityi/engine-lib 1.3.1 → 1.4.0

package/dist/tools-web/index.js

@@ -0,0 +1,472 @@
+import {
+  createHttpToolClient
+} from "../index-mr1hs98z.js";
+import"../index-k0q7x4mz.js";
+import"../index-zdggff0y.js";
+import {
+  s
+} from "../index-mnx5mqbs.js";
+import"../index-4c15ysa8.js";
+import"../index-ajr3nk10.js";
+import {
+  defineTool
+} from "../index-a67ej96j.js";
+import"../index-37x76zdn.js";
+
+// src/tools-web/define.ts
+import { Readability } from "@mozilla/readability";
+import robotsParser from "robots-parser";
+
+// src/tools-web/html.ts
+import { parseHTML } from "linkedom";
+function compactWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function documentFromHtml(html) {
+  return parseHTML(html).document;
+}
+function removeNoise(document) {
+  for (const selector of ["script", "style", "noscript", "template", "svg"]) {
+    for (const node of Array.from(document.querySelectorAll(selector))) {
+      node.remove?.();
+    }
+  }
+}
+function normalizeUrl(raw, baseUrl) {
+  try {
+    const url = new URL(raw, baseUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return null;
+    url.hash = "";
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+function parseStaticHtml(html, baseUrl, maxLinks = Number.POSITIVE_INFINITY) {
+  const document = documentFromHtml(html);
+  const title = compactWhitespace(document.querySelector("title")?.textContent ?? "");
+  removeNoise(document);
+  const root = document.body ?? document.documentElement;
+  const text = compactWhitespace(root?.textContent ?? "");
+  const links = [];
+  const seen = new Set;
+  for (const anchor of Array.from(document.querySelectorAll("a[href]"))) {
+    if (links.length >= maxLinks)
+      break;
+    if (anchor.getAttribute === undefined)
+      continue;
+    const href = anchor.getAttribute("href");
+    if (href === null)
+      continue;
+    const url = normalizeUrl(href, baseUrl);
+    if (url === null || seen.has(url))
+      continue;
+    seen.add(url);
+    const linkText = compactWhitespace(anchor.textContent ?? "");
+    links.push({ url, ...linkText !== "" ? { text: linkText } : {} });
+  }
+  return {
+    ...title !== "" ? { title } : {},
+    text,
+    links
+  };
+}
+function readabilityDocument(html) {
+  return documentFromHtml(html);
+}
+function compactText(text) {
+  return compactWhitespace(text);
+}
+
+// src/tools-web/define.ts
+var DEFAULT_USER_AGENT = "engine-lib";
+var DEFAULT_MAX_SEARCH_RESULTS = 10;
+var DEFAULT_MAX_PAGE_TEXT_CHARS = 12000;
+var DEFAULT_MAX_CRAWL_PAGES = 10;
+var DEFAULT_MAX_LINKS_PER_PAGE = 25;
+var WEB_SEARCH_PARAMS = s.object({
+  query: s.string({ description: "Search query." }),
+  max_results: s.optional(s.number({ int: true, description: "Maximum results to return." }))
+});
+var URL_PARAMS = s.object({
+  url: s.string({ description: "Absolute http(s) URL." }),
+  max_body_chars: s.optional(s.number({ int: true, description: "Returned text character cap." }))
+});
+var CRAWL_PARAMS = s.object({
+  url: s.string({ description: "Absolute http(s) URL to start from." }),
+  depth: s.optional(s.number({ int: true, description: "Maximum crawl depth from the start URL." })),
+  max_pages: s.optional(s.number({ int: true, description: "Maximum pages to fetch." })),
+  max_links_per_page: s.optional(s.number({ int: true, description: "Maximum links to keep from each page." })),
+  same_host: s.optional(s.boolean({ description: "Restrict crawl to the start URL host. Defaults to true." }))
+});
+function fail(error) {
+  if (error instanceof Error)
+    return { ok: false, error: error.message };
+  return { ok: false, error: String(error) };
+}
+function clamp(value, fallback, min, max) {
+  const n = value ?? fallback;
+  return Math.max(min, Math.min(max, n));
+}
+function firstSnippet(text, max = 240) {
+  const compact = compactText(text);
+  if (compact === "")
+    return;
+  return compact.length <= max ? compact : compact.slice(0, max);
+}
+function isHtml(result) {
+  const type = (result.contentType ?? "").toLowerCase();
+  return type.includes("text/html") || type.includes("application/xhtml+xml");
+}
+function titleFromTextFallback(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+function sourceFor(requestedUrl, result, fetchedAt, title, snippet, robots) {
+  return {
+    url: requestedUrl,
+    finalUrl: result.finalUrl,
+    ...title !== undefined ? { title } : {},
+    fetchedAt,
+    ...result.contentType !== undefined ? { contentType: result.contentType } : {},
+    status: result.status,
+    ...snippet !== undefined ? { snippet } : {},
+    ...robots !== undefined ? { robots } : {}
+  };
+}
+function citationFor(source) {
+  return {
+    url: source.finalUrl,
+    ...source.title !== undefined ? { title: source.title } : {},
+    ...source.snippet !== undefined ? { snippet: source.snippet } : {},
+    fetchedAt: source.fetchedAt
+  };
+}
+function normalizeSearchResult(result, fetchedAt) {
+  const source = result.source ?? {
+    url: result.url,
+    finalUrl: result.url,
+    ...result.title !== undefined ? { title: result.title } : {},
+    fetchedAt,
+    ...result.snippet !== undefined ? { snippet: result.snippet } : {}
+  };
+  return {
+    url: result.url,
+    ...result.title !== undefined ? { title: result.title } : source.title !== undefined ? { title: source.title } : {},
+    ...result.snippet !== undefined ? { snippet: result.snippet } : source.snippet !== undefined ? { snippet: source.snippet } : {},
+    source,
+    citation: result.citation ?? citationFor(source)
+  };
+}
+function robotsPolicyFor(config, url) {
+  const host = url.hostname.toLowerCase();
+  return config.robotsByHost?.[host] ?? config.robots ?? "enforce";
+}
+function originOf(url) {
+  return `${url.protocol}//${url.host}`;
+}
+function robotsUrlFor(url) {
+  return `${originOf(url)}/robots.txt`;
+}
+function sameHost(url, start) {
+  try {
+    const next = new URL(url);
+    return next.hostname.toLowerCase() === start.hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function normalizeFetchText(result, maxChars) {
+  if (typeof result.body === "string" && isHtml(result)) {
+    const parsed = parseStaticHtml(result.body, result.finalUrl);
+    const limited = result.bodyTruncated || parsed.text.length > maxChars;
+    return {
+      text: parsed.text.slice(0, maxChars),
+      html: result.body,
+      title: parsed.title,
+      links: parsed.links,
+      truncated: limited,
+      bodyTruncated: result.bodyTruncated
+    };
+  }
+  if (typeof result.body === "string") {
+    const text = compactText(result.body);
+    return {
+      text: text.slice(0, maxChars),
+      links: [],
+      truncated: result.bodyTruncated || text.length > maxChars,
+      bodyTruncated: result.bodyTruncated
+    };
+  }
+  if (result.bodyJson !== undefined) {
+    const text = compactText(JSON.stringify(result.bodyJson));
+    return {
+      text: text.slice(0, maxChars),
+      links: [],
+      truncated: text.length > maxChars,
+      bodyTruncated: result.bodyTruncated
+    };
+  }
+  return { text: "", links: [], truncated: false, bodyTruncated: result.bodyTruncated };
+}
+function createRobotsChecker(config, http) {
+  const cache = new Map;
+  const userAgent = config.userAgent ?? DEFAULT_USER_AGENT;
+  async function fetchRobots(url, ctx) {
+    const origin = originOf(url);
+    const cached = cache.get(origin);
+    if (cached !== undefined)
+      return cached;
+    const promise = (async () => {
+      try {
+        const response = await http.get(robotsUrlFor(url), {
+          maxBytes: 512000,
+          maxBodyChars: 512000,
+          headers: [{ name: "user-agent", value: userAgent }]
+        }, ctx);
+        if (response.status < 200 || response.status >= 300 || typeof response.body !== "string") {
+          return { status: response.status, rules: robotsParser(robotsUrlFor(url), "") };
+        }
+        return {
+          status: response.status,
+          rules: robotsParser(robotsUrlFor(url), response.body)
+        };
+      } catch (error) {
+        return { status: "error", error: error instanceof Error ? error.message : String(error) };
+      }
+    })();
+    cache.set(origin, promise);
+    return promise;
+  }
+  return async function checkRobots(rawUrl, ctx) {
+    const url = new URL(rawUrl);
+    const policy = robotsPolicyFor(config, url);
+    if (policy === "ignore")
+      return { policy };
+    const record = await fetchRobots(url, ctx);
+    if (record.status === "error") {
+      const robots2 = { policy, reason: record.error };
+      if (policy === "enforce") {
+        throw new Error(`robots.txt could not be fetched for ${originOf(url)}: ${record.error}`);
+      }
+      return robots2;
+    }
+    const allowed = record.rules?.isAllowed(rawUrl, userAgent);
+    const isAllowed = allowed !== false;
+    const robots = {
+      policy,
+      allowed: isAllowed,
+      ...!isAllowed ? { reason: "robots.txt disallows this URL" } : {}
+    };
+    if (!isAllowed && policy === "enforce") {
+      throw new Error(`robots.txt disallows ${rawUrl}`);
+    }
+    return robots;
+  };
+}
+function webTools(config) {
+  const http = config.httpClient ?? createHttpToolClient(config);
+  const checkRobots = createRobotsChecker(config, http);
+  const maxSearchResults = config.maxSearchResults ?? DEFAULT_MAX_SEARCH_RESULTS;
+  const maxPageTextChars = config.maxPageTextChars ?? DEFAULT_MAX_PAGE_TEXT_CHARS;
+  const maxCrawlPages = config.maxCrawlPages ?? DEFAULT_MAX_CRAWL_PAGES;
+  const maxLinksPerPage = config.maxLinksPerPage ?? DEFAULT_MAX_LINKS_PER_PAGE;
+  async function fetchPageInternal(rawUrl, maxChars, ctx) {
+    const robots = await checkRobots(rawUrl, ctx);
+    const response = await http.get(rawUrl, {
+      maxBodyChars: Math.max(maxChars * 4, maxChars),
+      headers: [{ name: "user-agent", value: config.userAgent ?? DEFAULT_USER_AGENT }]
+    }, ctx);
+    const fetchedAt = new Date().toISOString();
+    const textInfo = normalizeFetchText(response, maxChars);
+    const snippet = firstSnippet(textInfo.text);
+    const title = textInfo.title ?? titleFromTextFallback(response.finalUrl);
+    const source = sourceFor(rawUrl, response, fetchedAt, title, snippet, robots);
+    return {
+      source,
+      citation: citationFor(source),
+      text: textInfo.text,
+      textTruncated: textInfo.truncated,
+      bodyTruncated: textInfo.bodyTruncated,
+      html: textInfo.html,
+      links: textInfo.links
+    };
+  }
+  const webSearch = defineTool({
+    name: "web_search",
+    description: "Search the web through the host's injected search provider and return normalized citations.",
+    parameters: WEB_SEARCH_PARAMS,
+    async execute(args, ctx) {
+      try {
+        if (config.searchProvider === undefined) {
+          return { ok: false, error: "web_search requires a searchProvider" };
+        }
+        const maxResults = clamp(args.max_results, maxSearchResults, 1, maxSearchResults);
+        const fetchedAt = new Date().toISOString();
+        const raw = await config.searchProvider.search({ query: args.query, maxResults }, ctx);
+        const results = raw.slice(0, maxResults).map((result) => normalizeSearchResult(result, fetchedAt));
+        return {
+          ok: true,
+          content: {
+            query: args.query,
+            results,
+            truncated: raw.length > results.length
+          }
+        };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  });
+  const fetchPage = defineTool({
+    name: "fetch_page",
+    description: "Fetch one static HTML/text page and return compact text with source metadata and a citation.",
+    parameters: URL_PARAMS,
+    async execute(args, ctx) {
+      try {
+        const maxChars = clamp(args.max_body_chars, maxPageTextChars, 1, maxPageTextChars);
+        const page = await fetchPageInternal(args.url, maxChars, ctx);
+        return {
+          ok: true,
+          content: {
+            source: page.source,
+            citation: page.citation,
+            text: page.text,
+            textTruncated: page.textTruncated
+          }
+        };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  });
+  const extractReadableText = defineTool({
+    name: "extract_readable_text",
+    description: "Fetch one static page and extract readable article text, falling back to page text.",
+    parameters: URL_PARAMS,
+    async execute(args, ctx) {
+      try {
+        const maxChars = clamp(args.max_body_chars, maxPageTextChars, 1, maxPageTextChars);
+        const page = await fetchPageInternal(args.url, maxChars, ctx);
+        let text = page.text;
+        let title = page.source.title;
+        let textTruncated = page.textTruncated;
+        let readable = false;
+        let byline;
+        let excerpt;
+        if (page.html !== undefined) {
+          try {
+            const article = new Readability(readabilityDocument(page.html), {
+              charThreshold: 20
+            }).parse();
+            const articleText = compactText(article?.textContent ?? "");
+            if (articleText !== "") {
+              const articleTruncated = articleText.length > maxChars;
+              text = articleText.slice(0, maxChars);
+              textTruncated = page.bodyTruncated || articleTruncated;
+              title = article?.title ?? title;
+              byline = article?.byline ?? undefined;
+              excerpt = article?.excerpt ?? undefined;
+              readable = true;
+            }
+          } catch {
+            readable = false;
+          }
+        }
+        const source = {
+          ...page.source,
+          ...title !== undefined ? { title } : {},
+          ...firstSnippet(text) !== undefined ? { snippet: firstSnippet(text) } : {}
+        };
+        return {
+          ok: true,
+          content: {
+            source,
+            citation: citationFor(source),
+            title,
+            text,
+            textTruncated,
+            readable,
+            ...byline !== undefined ? { byline } : {},
+            ...excerpt !== undefined ? { excerpt } : {}
+          }
+        };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  });
+  const crawlLinks = defineTool({
+    name: "crawl_links",
+    description: "Fetch a bounded set of static pages and return same-host links by default.",
+    parameters: CRAWL_PARAMS,
+    async execute(args, ctx) {
+      try {
+        const start = new URL(args.url);
+        const depth = clamp(args.depth, 1, 0, 5);
+        const maxPages = clamp(args.max_pages, maxCrawlPages, 1, maxCrawlPages);
+        const linksPerPage = clamp(args.max_links_per_page, maxLinksPerPage, 1, maxLinksPerPage);
+        const requireSameHost = args.same_host ?? true;
+        const queue = [{ url: start.href, depth: 0 }];
+        const queued = new Set([start.href]);
+        const seen = new Set;
+        let truncated = false;
+        const pages = [];
+        const errors = [];
+        while (queue.length > 0 && pages.length < maxPages) {
+          const next = queue.shift();
+          queued.delete(next.url);
+          if (seen.has(next.url))
+            continue;
+          seen.add(next.url);
+          if (requireSameHost && !sameHost(next.url, start))
+            continue;
+          let page;
+          try {
+            page = await fetchPageInternal(next.url, maxPageTextChars, ctx);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (next.depth === 0)
+              throw error;
+            errors.push({ url: next.url, error: message });
+            continue;
+          }
+          const eligibleLinks = requireSameHost ? page.links.filter((link) => sameHost(link.url, start)) : page.links;
+          const links = eligibleLinks.slice(0, linksPerPage);
+          if (eligibleLinks.length > links.length)
+            truncated = true;
+          pages.push({ source: page.source, citation: page.citation, links });
+          if (next.depth < depth) {
+            for (const link of links) {
+              if (seen.has(link.url))
+                continue;
+              if (queued.has(link.url))
+                continue;
+              queue.push({ url: link.url, depth: next.depth + 1 });
+              queued.add(link.url);
+            }
+          }
+        }
+        return {
+          ok: true,
+          content: {
+            startUrl: start.href,
+            pages,
+            errors,
+            truncated: truncated || queue.length > 0
+          }
+        };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  });
+  return { webSearch, fetchPage, extractReadableText, crawlLinks };
+}
+export {
+  webTools
+};

package/dist/tools-web/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Public types for `@infinityi/engine-lib/tools-web`.
+ *
+ * Web tools sit above `tools-http`: they fetch static HTML/text, normalize
+ * search results from an injected provider, extract readable article text, and
+ * crawl bounded same-host links.
+ *
+ * @module
+ */
+import type { EngineContext } from "../runtime/types";
+import type { ToolDefinition } from "../tools/types";
+import type { HttpToolClient, HttpToolsConfig } from "../tools-http";
+/** Robots handling mode for page fetches and crawling. */
+export type RobotsPolicy = "enforce" | "metadata" | "ignore";
+/** Request passed to an injected search provider. */
+export interface SearchRequest {
+    readonly query: string;
+    readonly maxResults: number;
+}
+/** Search result shape accepted from and returned by web search. */
+export interface SearchResult {
+    readonly url: string;
+    readonly title?: string;
+    readonly snippet?: string;
+    readonly source?: SourceMetadata;
+    readonly citation?: Citation;
+}
+/** Search provider contract. No built-in paid/vendor provider is bundled. */
+export interface SearchProvider {
+    search(request: SearchRequest, ctx?: EngineContext): Promise<readonly SearchResult[]> | readonly SearchResult[];
+}
+/** Compact source metadata carried by every web result. */
+export interface SourceMetadata {
+    readonly url: string;
+    readonly finalUrl: string;
+    readonly title?: string;
+    readonly fetchedAt: string;
+    readonly contentType?: string;
+    readonly status?: number;
+    readonly snippet?: string;
+    readonly robots?: {
+        readonly policy: RobotsPolicy;
+        readonly allowed?: boolean;
+        readonly reason?: string;
+    };
+}
+/** Citation metadata suitable for model-visible attribution. */
+export interface Citation {
+    readonly url: string;
+    readonly title?: string;
+    readonly snippet?: string;
+    readonly fetchedAt: string;
+}
+/** Configuration for {@link webTools}. */
+export interface WebToolsConfig extends HttpToolsConfig {
+    /** Optional prebuilt HTTP client. If omitted, one is created from this config. */
+    readonly httpClient?: HttpToolClient;
+    /** Provider used by `web_search`; omitted providers make only that tool fail. */
+    readonly searchProvider?: SearchProvider;
+    /** Global robots policy. Defaults to `enforce`. */
+    readonly robots?: RobotsPolicy;
+    /** Per-host robots policy overrides, keyed by lower-case hostname. */
+    readonly robotsByHost?: Readonly<Record<string, RobotsPolicy>>;
+    /** User-Agent used for robots checks and optional default request headers. */
+    readonly userAgent?: string;
+    /** Upper bound for `web_search.max_results`. Defaults to 10. */
+    readonly maxSearchResults?: number;
+    /** Upper bound for returned page text. Defaults to 12_000 characters. */
+    readonly maxPageTextChars?: number;
+    /** Upper bound for crawl pages. Defaults to 10. */
+    readonly maxCrawlPages?: number;
+    /** Upper bound for links returned per crawled page. Defaults to 25. */
+    readonly maxLinksPerPage?: number;
+}
+/** The ready-made web tool definitions. */
+export interface WebTools {
+    readonly webSearch: ToolDefinition;
+    readonly fetchPage: ToolDefinition;
+    readonly extractReadableText: ToolDefinition;
+    readonly crawlLinks: ToolDefinition;
+}

package/docs/README.md

@@ -1,19 +1,63 @@
 # engine-lib documentation
 
-- **Guide & concepts:** [`../README.md`](../README.md) - project goal, design principles, and annotated usage scenarios.
-- **Runnable examples:** [`../examples/`](../examples/) - small, offline programs you can run with `bun`.
+Start with the repository [`README.md`](../README.md) for project goals,
+constraints, and the fastest overview. Use these pages when you need runnable
+examples, import-path details, or feature-specific behavior.
 
-## API reference
+## Guides
+
+| Guide | Covers |
+| --- | --- |
+| [Getting started](./getting-started.md) | installation, quickstart, examples, and API docs |
+| [Providers](./providers.md) | built-in provider factories, capabilities, custom adapters |
+| [Tools and schemas](./tools.md) | `s`, `defineTool`, tool results, error recovery |
+| [Execution](./execution.md) | `runAgent`, streaming, cancellation, run failures |
+| [Sessions and context](./sessions-and-context.md) | durable history, context injection, context windows |
+| [Events and telemetry](./events-and-telemetry.md) | run events, subscribers, telemetry integration |
+| [Multi-agent](./multi-agent.md) | handoffs, registries, and sub-agents as tools |
+| [Optional tool packs](./optional-tool-packs.md) | shell, filesystem, HTTP, and web tool safety |
+| [Testing and lifecycle](./testing-and-lifecycle.md) | test doubles, conformance, Forge lifecycle |
+
+## Examples
+
+Runnable examples live in [`../examples/`](../examples/). Most use mock
+providers or fake transports and do not need network credentials.
+
+```bash
+bun run examples
+```
+
+The example set includes:
+
+- `examples/incident-analysis.ts` - an offline end-to-end agent with a tool,
+  context, session, and events
+- `examples/01-minimal-agent.ts` - smallest buffered run
+- `examples/02-custom-tool.ts` - typed tool parameters and tool results
+- `examples/03-streaming.ts` - streaming events and `completed`
+- `examples/04-sessions-context.ts` - session history and injected context
+- `examples/05-events-subscribers.ts` - subscriber fan-out and failure isolation
+- `examples/06-multi-agent-handoff.ts` - handoff to a specialist
+- `examples/07-sub-agent-tool.ts` - `asTool` delegation
+- `examples/08-testing-agent.ts` - deterministic agent test pattern
+- `examples/09-tools-filesystem.ts` - allowed-root filesystem tools
+- `examples/10-tools-http-web.ts` - HTTP and web tools with fake fetch/search
+- `examples/11-shell-tools.ts` - policy-gated command execution
+- `examples/12-provider-openai.ts` - real OpenAI provider, gated by env
+- `examples/13-lifecycle.ts` - Forge lifecycle component shape
+
+## API Reference
 
 The full API reference is generated from source doc-comments with
 [TypeDoc](https://typedoc.org):
 
 ```bash
-bun run docs   # writes HTML to docs/api/ (git-ignored)
+bun run docs
 ```
 
-Then open `docs/api/index.html`. Configuration lives in `typedoc.json` in the
-source repository; the documented entry points are the public import surfaces:
+Then open `docs/api/index.html`. The output is git-ignored; regenerate it
+locally or publish it from CI.
+
+The TypeDoc entry points are aligned with the public package exports:
 
 | Import | Module |
 | --- | --- |
@@ -24,13 +68,17 @@ source repository; the documented entry points are the public import surfaces:
 | `@infinityi/engine-lib/runtime` | Forge secret and telemetry integration helpers |
 | `@infinityi/engine-lib/providers` | provider contracts, built-in provider factories, and advanced adapter/HTTP/SSE helpers |
 | `@infinityi/engine-lib/tools` | tool definitions and tool-result mapping helpers |
+| `@infinityi/engine-lib/tools-shell` | optional policy-gated command execution tools |
+| `@infinityi/engine-lib/tools-fs` | optional allowed-root filesystem and workspace tools |
+| `@infinityi/engine-lib/tools-http` | optional policy-gated HTTP GET/POST tools and client |
+| `@infinityi/engine-lib/tools-web` | optional static web/search tools built on `tools-http` |
 | `@infinityi/engine-lib/agent` | agent definitions, registries, handoffs, and sub-agent-as-tool helpers |
 | `@infinityi/engine-lib/execution` | `runAgent` and run result/event types |
 | `@infinityi/engine-lib/session` | session handles and session store contract |
+| `@infinityi/engine-lib/session-stores` | optional durable session stores for Forge SQL, SQLite, PostgreSQL, Redis, and filesystem JSONL |
 | `@infinityi/engine-lib/context` | context providers and context-window strategies |
+| `@infinityi/engine-lib/retrieval` | optional RAG primitives: document loaders, chunkers, embeddings, vector stores, retrievers, and retriever context providers |
 | `@infinityi/engine-lib/events` | event hub, subscribers, event projection helpers, and telemetry bridge |
 | `@infinityi/engine-lib/lifecycle` | Forge lifecycle adapter (`agentRuntimeComponent`) |
-| `@infinityi/engine-lib/testing` | network-free test doubles (`mockProvider`, `scriptedProvider`, `textResult`, `toolCallResult`, `jsonFetch`/`sseFetch`, `inMemorySessionStore`) |
-| `@infinityi/engine-lib/testing/conformance` | the provider conformance battery (`runProviderConformance`) |
-
-The output is intentionally not committed; regenerate it locally or in CI.
+| `@infinityi/engine-lib/testing` | network-free test doubles |
+| `@infinityi/engine-lib/testing/conformance` | provider conformance battery |

package/docs/api/.nojekyll

@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.

package/docs/api/assets/hierarchy.js

@@ -0,0 +1 @@
+window.hierarchyData = "eJydlstO4zAUht/Fa7fEuThxdiOmiBkJDZqOYIFYmOS0tca1K9sMRajvPkrLxUkDcbrpojq/v9/n5rwgo7WzqLwrME1TTGhEcUZzTCKa32NkYCGhckIri8oXVDQ/iq8BlejbEpSbGaMNwuivUDUqSVxg9GgkKlElubVgz6AJsNOP4OnKrSXChwBUImfrSaOeHP7AqFoJWRtQqLxLMkwzzDJMshzHaYrjnOAkSnCSRPc7jJLM83Nt9D9Rgwm11IofcLXDiPqsP1rLUM577DCD+Yx5tYI1v+FS1LwpQCivVzcm6yTOmuSSuHvj8V56VMNZIFnugWdbqB7HMNuCURcvUhyTdH/5IvU8XPHt3MHGzrYVQA11qJVe3XACYtKBX3JV68XiFH6vNMBC6ls456oCKcPBbUEALic+TisHW3crVK2fgpFHomFsEiX+wK1AymstRfUcPGsdSQAyiTzkhZBgn62D9Thur24YntH8aMG80+KMvtGEcmAWvAJ7JlQN29ed8ingPb4zT4TmzTDRVjPN1FIoeC1XEL2lGGsiLyguiv1Gywva2WhjXHjxAR52GBWFv0B/KOvM4/4pHUM9loXBSZSQFv0K1to8z8FaodXcaQNf9dkb/FgVsL+jdpv1Ib9sthDaZy3HUoYJi1LcJAATxhiOSRLhmLD9J0PTk565X5sms1wGzYI9TEFbE1gOGvm9d+nc5jC5A0intbSTlXOb6YdmdFJoRvZ3pxnpmGia2p5rtRDLcU484Wg7OTmUIif+LryFh7FunuBh2pYFVoNF/ka60GYJ37njodNhD3ET2wTaaa8+YE5Yynrfgp9WK3mql89PCXHEfEe/oRb2RB9H2pDPntbbeC61Bf4gYcQC6ZjoPSKsRZp94Zm5AdMcAPXpZnqPCDGz2/0HFTOXRQ=="