@fenixforce/kernel 0.1.0

package/dist/testing/workflow-evals.d.ts

@@ -0,0 +1,73 @@
+export type ToolExecutor = (input: Record<string, unknown>) => Promise<unknown>;
+export interface MockScenario {
+    name: string;
+    match: Record<string, unknown>;
+    output: unknown;
+}
+export interface ToolDefinition {
+    name: string;
+    live: ToolExecutor;
+    mock?: ToolExecutor;
+    mockSchema?: MockScenario[];
+}
+export interface AgentInput {
+    prompt: string;
+    systemPrompt?: string;
+    tools?: string[];
+    context?: Record<string, unknown>;
+}
+export interface AgentEvent {
+    type: string;
+    tool?: string;
+    output?: unknown;
+    error?: string;
+    [key: string]: unknown;
+}
+export interface EvalCase {
+    name: string;
+    input: AgentInput;
+    /** Events that must fire during the run */
+    expectedEvents: Partial<AgentEvent>[];
+    /** Events that must NOT fire */
+    forbiddenEvents?: Partial<AgentEvent>[];
+    toolMode: "live" | "mock" | "mixed";
+    mockScenario?: string;
+    maxTurns: number;
+    timeout: number;
+}
+export interface EvalResult {
+    caseName: string;
+    passed: boolean;
+    /** Matched expected events */
+    matchedEvents: Partial<AgentEvent>[];
+    /** Expected events that were not found */
+    missingEvents: Partial<AgentEvent>[];
+    /** Forbidden events that were found */
+    violatedForbidden: Partial<AgentEvent>[];
+    /** All events that occurred */
+    actualEvents: AgentEvent[];
+    elapsedMs: number;
+    error?: string;
+}
+export type AgentRunnerFn = (input: AgentInput, tools: Map<string, ToolExecutor>, maxTurns: number) => Promise<AgentEvent[]>;
+export declare class EvalToolRegistry {
+    private tools;
+    register(definition: ToolDefinition): void;
+    /**
+     * Build a tool executor map for a given eval mode and scenario.
+     */
+    resolveTools(mode: "live" | "mock" | "mixed", scenarioName?: string): Map<string, ToolExecutor>;
+    private buildMockExecutor;
+}
+/**
+ * Run a single eval case and return the result.
+ */
+export declare function runEval(evalCase: EvalCase, registry: EvalToolRegistry, agentRunner: AgentRunnerFn): Promise<EvalResult>;
+/**
+ * Run all eval cases and return aggregated results.
+ */
+export declare function runEvalSuite(cases: EvalCase[], registry: EvalToolRegistry, agentRunner: AgentRunnerFn): Promise<{
+    results: EvalResult[];
+    passCount: number;
+    failCount: number;
+}>;

package/dist/tools/access-control.d.ts

@@ -0,0 +1,60 @@
+import type { ToolDefinition, ToolContext } from "./registry.js";
+export interface AccessDenied {
+    tool: string;
+    reason: string;
+    missing: string[];
+}
+export interface WorkspaceToolConfig {
+    /** If set, only these tools are available (whitelist).
+     *  Supports exact names ("file.read") and prefix globs ("file.*"). */
+    whitelist?: string[];
+    /** If set, these tools are removed from availability (blacklist).
+     *  Supports exact names and prefix globs. Blacklist wins over whitelist. */
+    blacklist?: string[];
+}
+export interface EditionToolConfig {
+    /** Tool names available in this edition. Use "*" for all. */
+    tools: string[];
+    /** Tool categories included (matched against tool name prefixes like "file.*"). */
+    categories?: string[];
+}
+export interface ACLCheckResult {
+    allowed: boolean;
+    tool: string;
+    reason: string;
+}
+export declare class AccessControl {
+    private workspaceConfig;
+    private editionConfig;
+    /**
+     * Check whether the context has all permissions required by the tool.
+     * Returns true if the tool has no required permissions, or if the
+     * context includes every required permission.
+     */
+    canAccess(tool: ToolDefinition, context: ToolContext): boolean;
+    /**
+     * Like canAccess but returns an AccessDenied descriptor on failure,
+     * or null if access is granted.
+     */
+    check(tool: ToolDefinition, context: ToolContext): AccessDenied | null;
+    /** Set workspace-level whitelist/blacklist restrictions. */
+    setWorkspaceConfig(config: WorkspaceToolConfig): void;
+    /** Get the current workspace config. */
+    getWorkspaceConfig(): WorkspaceToolConfig;
+    /** Set the active edition's tool configuration. */
+    setEditionConfig(config: EditionToolConfig): void;
+    /** Get the current edition config. */
+    getEditionConfig(): EditionToolConfig | null;
+    /**
+     * Full ACL check: edition → workspace → permissions.
+     * Returns whether a tool is accessible given all layers.
+     */
+    checkACL(tool: ToolDefinition, context: ToolContext): ACLCheckResult;
+    /**
+     * Filter a list of tools down to only those visible to the agent.
+     * Tools not passing the ACL are excluded from the system prompt.
+     */
+    filterVisible(tools: ToolDefinition[], context: ToolContext): ToolDefinition[];
+    private isToolInEdition;
+    private matchesPattern;
+}

package/dist/tools/browser-engine.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Browser Engine — wraps Playwright for web navigation, interaction,
+ * and content extraction. Single browser instance reused across calls.
+ *
+ * Content isolation: all extracted content is wrapped with
+ * [WEB_CONTENT_START]...[WEB_CONTENT_END] markers and tagged as
+ * web_content instruction source.
+ */
+export interface BrowserPage {
+    goto(url: string, options?: {
+        waitUntil?: string;
+    }): Promise<{
+        status: () => number | null;
+    }>;
+    title(): Promise<string>;
+    click(selector: string): Promise<void>;
+    fill(selector: string, value: string): Promise<void>;
+    screenshot(options?: {
+        type?: string;
+        encoding?: string;
+    }): Promise<string | Buffer>;
+    evaluate<T>(fn: () => T): Promise<T>;
+    $eval<T>(selector: string, fn: (el: Element) => T): Promise<T>;
+    close(): Promise<void>;
+    content(): Promise<string>;
+}
+export interface Browser {
+    newPage(): Promise<BrowserPage>;
+    close(): Promise<void>;
+}
+export interface BrowserLauncher {
+    launch(options?: Record<string, unknown>): Promise<Browser>;
+}
+export interface NavigateResult {
+    title: string;
+    summary: string;
+    url: string;
+}
+export interface ExtractResult {
+    content: string;
+    title: string;
+    url: string;
+}
+export declare class BrowserEngine {
+    private browser;
+    private page;
+    private currentUrl;
+    private readonly launcher;
+    constructor(launcher: BrowserLauncher);
+    private ensurePage;
+    /** Navigate to URL, return page title and content summary. */
+    navigate(url: string): Promise<NavigateResult>;
+    /** Click an element by CSS selector. */
+    click(selector: string): Promise<{
+        clicked: boolean;
+        selector: string;
+    }>;
+    /** Fill an input field by CSS selector. */
+    type(selector: string, text: string): Promise<{
+        filled: boolean;
+        selector: string;
+    }>;
+    /** Extract cleaned page content, stripping nav/ads/scripts. */
+    extract(selector?: string): Promise<ExtractResult>;
+    /** Capture viewport as base64 PNG for vision LLM analysis. */
+    screenshot(): Promise<{
+        image: string;
+        format: string;
+        url: string;
+    }>;
+    /** Cleanup — call on agent:end. */
+    close(): Promise<void>;
+}

package/dist/tools/builtins/jobs-router.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from "../registry.js";
+import type { JobQueue } from "../../job-queue.js";
+/**
+ * Create job management tools backed by the given JobQueue.
+ * Tools: jobs.submit, jobs.status, jobs.list, jobs.cancel
+ */
+export declare function createJobsTools(queue: JobQueue): ToolDefinition[];

package/dist/tools/builtins/tasks-router.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDefinition } from "../registry.js";
+export type TaskStatus = "pending" | "in_progress" | "done";
+export interface Task {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    priority: "low" | "normal" | "high";
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class TaskStore {
+    private tasks;
+    private nextId;
+    create(title: string, priority?: Task["priority"]): Task;
+    get(id: string): Task | undefined;
+    list(status?: TaskStatus): Task[];
+    update(id: string, fields: Partial<Pick<Task, "title" | "status" | "priority">>): Task;
+    delete(id: string): boolean;
+    get size(): number;
+}
+/**
+ * Create task management tools backed by the given store.
+ * Tools: tasks.create, tasks.get, tasks.list, tasks.update, tasks.delete
+ */
+export declare function createTasksTools(store: TaskStore): ToolDefinition[];

package/dist/tools/index.d.ts

@@ -0,0 +1,20 @@
+export { ToolRouter, type ToolCall, type ToolResult } from "./router.js";
+export { ToolRegistry, type ToolDefinition, type ToolContext, type ToolHandler, type ParameterDef } from "./registry.js";
+export { AccessControl, type AccessDenied } from "./access-control.js";
+export { createTasksTools, TaskStore, type Task, type TaskStatus } from "./builtins/tasks-router.js";
+export { createMemoryTools } from "./routers/memory-router.js";
+export { createWebTools } from "./routers/web-router.js";
+export { createCodeTools } from "./routers/code-router.js";
+export { createFileTools } from "./routers/file-router.js";
+export { createScheduleTools } from "./routers/schedule-router.js";
+export { createTaskPlanTools } from "./routers/task-router.js";
+export { createBrowserTools } from "./routers/browser-router.js";
+export { BrowserEngine } from "./browser-engine.js";
+export type { BrowserPage, Browser, BrowserLauncher, NavigateResult, ExtractResult, } from "./browser-engine.js";
+export { discoverSkills, extractFrontmatter, formatSkillForAgent, searchSkills, matchSkillsByTrigger } from "./skill-discovery.js";
+export type { Skill, SkillValidationError } from "./skill-discovery.js";
+export { LazySkillRegistry, loadSkillsLazy, loadSkills } from "./skill-loader.js";
+export type { SkillLoaderConfig, SkillLoadResult, SkillStub } from "./skill-loader.js";
+export type { SkillDefinition, SkillCategory, McpServerRef } from "./skill-types.js";
+export { MapReduceEngine, countReducer, majorityVoteReducer, filterReducer } from "./map-reduce.js";
+export type { ContentChunk as MapReduceChunk, StructuredOutputSchema, MapReduceOpts, MapResult, LLMMapCallFn, MapReduceConfig, } from "./map-reduce.js";

package/dist/tools/map-reduce.d.ts

@@ -0,0 +1,64 @@
+export interface ContentChunk {
+    id: string;
+    sourceId: string;
+    content: string;
+    chunkIndex: number;
+    metadata: Record<string, unknown>;
+}
+export interface StructuredOutputSchema {
+    type: string;
+    properties?: Record<string, unknown>;
+    enum?: string[];
+    description?: string;
+}
+export interface MapReduceOpts<MapOut, ReduceOut> {
+    chunks: ContentChunk[];
+    /** Prompt template — {content} is replaced with chunk content */
+    mapPrompt: string;
+    /** JSON schema for constrained map output */
+    mapSchema: StructuredOutputSchema;
+    /** Deterministic aggregation of validated map outputs */
+    reduce: (results: MapOut[]) => ReduceOut | Promise<ReduceOut>;
+}
+export interface MapResult<T> {
+    chunkId: string;
+    output: T;
+    success: boolean;
+    error?: string;
+}
+export type LLMMapCallFn = (prompt: string, schema: StructuredOutputSchema) => Promise<unknown>;
+export type JobEnqueueFn = (type: string, payload: unknown) => Promise<string>;
+export interface MapReduceConfig {
+    /** Max parallel map workers (default: 10) */
+    maxConcurrency: number;
+    /** LLM call function for map phase */
+    llmCall: LLMMapCallFn;
+    /** Optional: route map calls through job queue */
+    enqueueJob?: JobEnqueueFn;
+}
+export declare class MapReduceEngine {
+    private config;
+    constructor(config: MapReduceConfig);
+    /**
+     * Execute map-reduce over untrusted document chunks.
+     * Each chunk is processed in isolation — no cross-contamination.
+     */
+    mapReduce<MapOut, ReduceOut>(opts: MapReduceOpts<MapOut, ReduceOut>): Promise<ReduceOut>;
+    /** Get map results without reducing (for inspection/testing). */
+    map<MapOut>(chunks: ContentChunk[], mapPrompt: string, mapSchema: StructuredOutputSchema): Promise<MapResult<MapOut>[]>;
+    private executeMap;
+    private processChunk;
+}
+/** Count truthy values from boolean map outputs. */
+export declare function countReducer(results: boolean[]): {
+    total: number;
+    truthy: number;
+    falsy: number;
+};
+/** Majority vote from enum/string map outputs. */
+export declare function majorityVoteReducer(results: string[]): {
+    winner: string;
+    votes: Record<string, number>;
+};
+/** Filter and collect results matching a predicate. */
+export declare function filterReducer<T>(predicate: (item: T) => boolean): (results: T[]) => T[];

package/dist/tools/registry.d.ts

@@ -0,0 +1,39 @@
+export interface ParameterDef {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description?: string;
+    required?: boolean;
+}
+export interface ToolContext {
+    mode: string;
+    permissions: string[];
+    [key: string]: unknown;
+}
+export type ToolHandler = (params: Record<string, unknown>, context: ToolContext) => Promise<unknown>;
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters?: Record<string, ParameterDef>;
+    handler: ToolHandler;
+    /** Restrict to these modes (empty/undefined = available in all modes) */
+    modes?: string[];
+    /** ACL permission tags required to invoke this tool */
+    requiredPermissions?: string[];
+}
+export declare class ToolRegistry {
+    private tools;
+    /** Register a tool definition. Throws on duplicate name. */
+    register(tool: ToolDefinition): void;
+    /** Register multiple tools at once. */
+    registerAll(tools: ToolDefinition[]): void;
+    /** Get a tool by name, or undefined. */
+    get(name: string): ToolDefinition | undefined;
+    /** Check if a tool is registered. */
+    has(name: string): boolean;
+    /**
+     * List tools, optionally filtered by mode.
+     * Tools with no mode restriction are always included.
+     */
+    list(mode?: string): ToolDefinition[];
+    /** Number of registered tools. */
+    get size(): number;
+}

package/dist/tools/router.d.ts

@@ -0,0 +1,30 @@
+import type { ToolRegistry, ToolDefinition, ToolContext } from "./registry.js";
+import { AccessControl } from "./access-control.js";
+export interface ToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolResult {
+    name: string;
+    result?: unknown;
+    error?: string;
+}
+export declare class ToolRouter {
+    private readonly registry;
+    private readonly acl;
+    constructor(registry: ToolRegistry, acl?: AccessControl);
+    /**
+     * Route a tool call to its handler.
+     *
+     * Checks:
+     * 1. Tool exists in registry
+     * 2. Tool is available in the current mode
+     * 3. Context has required permissions (ACL)
+     * 4. Invokes handler, catches errors
+     */
+    route(call: ToolCall, context: ToolContext): Promise<ToolResult>;
+    /**
+     * List tools available in the given context (mode + permissions).
+     */
+    listAvailable(context: ToolContext): ToolDefinition[];
+}

package/dist/tools/routers/browser-router.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser Router — exposes BrowserEngine actions as tool definitions.
+ *
+ * Tools: browser.navigate, browser.click, browser.type,
+ *        browser.extract, browser.screenshot
+ */
+import type { ToolDefinition } from "../registry.js";
+import type { BrowserEngine } from "../browser-engine.js";
+/**
+ * Create browser tools backed by the given BrowserEngine instance.
+ */
+export declare function createBrowserTools(engine: BrowserEngine): ToolDefinition[];

package/dist/tools/routers/code-router.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Code Router — exposes code execution and analysis as tool definitions.
+ *
+ * Tools: code.execute (sandboxed), code.analyze, code.explain
+ *
+ * code.execute runs in a sandboxed environment with timeout.
+ * code.analyze performs static analysis on a code snippet.
+ * code.explain generates a natural-language explanation.
+ */
+import type { ToolDefinition } from "../registry.js";
+export interface CodeExecutionResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    durationMs: number;
+}
+export interface CodeAnalysisResult {
+    language: string;
+    complexity: string;
+    issues: Array<{
+        line: number;
+        message: string;
+        severity: string;
+    }>;
+}
+export interface CodeBackend {
+    execute(code: string, language: string, timeoutMs?: number): Promise<CodeExecutionResult>;
+    analyze(code: string, language: string): Promise<CodeAnalysisResult>;
+    explain(code: string, language: string): Promise<string>;
+}
+/**
+ * Create code tools backed by the given CodeBackend.
+ */
+export declare function createCodeTools(backend: CodeBackend): ToolDefinition[];

package/dist/tools/routers/file-router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * File Router — exposes file system operations as tool definitions.
+ *
+ * Tools: files.read, files.write, files.list, files.search
+ *
+ * All operations are scoped to an allowed base directory for security.
+ */
+import type { ToolDefinition } from "../registry.js";
+export interface FileEntry {
+    path: string;
+    name: string;
+    size: number;
+    isDirectory: boolean;
+    modifiedAt: Date;
+}
+export interface FileSearchResult {
+    path: string;
+    line: number;
+    content: string;
+}
+export interface FileBackend {
+    read(path: string): Promise<string>;
+    write(path: string, content: string): Promise<{
+        written: boolean;
+        path: string;
+    }>;
+    list(directory: string, recursive?: boolean): Promise<FileEntry[]>;
+    search(directory: string, pattern: string, opts?: {
+        limit?: number;
+    }): Promise<FileSearchResult[]>;
+}
+/**
+ * Create file tools backed by the given FileBackend.
+ */
+export declare function createFileTools(backend: FileBackend): ToolDefinition[];

package/dist/tools/routers/memory-router.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Memory Router — exposes memory operations as tool definitions.
+ *
+ * Tools: memory.search, memory.expand, memory.context, memory.save,
+ *        memory.forget, memory.list, memory.graph
+ */
+import type { ToolDefinition } from "../registry.js";
+import type { MemorySegment, MemorySearchResult } from "../../storage/interface.js";
+export interface MemoryBackend {
+    search(userId: string, query: string, limit?: number): Promise<MemorySearchResult[]>;
+    searchByEmbedding(userId: string, embedding: number[], limit?: number): Promise<MemorySearchResult[]>;
+    save(userId: string, content: string, category: MemorySegment["category"]): Promise<MemorySegment>;
+    forget(segmentId: string): Promise<boolean>;
+    list(userId: string, category?: string, limit?: number): Promise<MemorySegment[]>;
+    getProfile(userId: string): Promise<string | null>;
+    graphQuery?(userId: string, entityName: string): Promise<unknown>;
+}
+/**
+ * Create memory tools backed by the given MemoryBackend.
+ */
+export declare function createMemoryTools(backend: MemoryBackend): ToolDefinition[];

package/dist/tools/routers/schedule-router.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Schedule Router — exposes scheduling operations as tool definitions.
+ *
+ * Tools: schedule.create, schedule.list, schedule.cancel
+ *
+ * Integrates with the job queue for deferred/recurring execution.
+ */
+import type { ToolDefinition } from "../registry.js";
+export interface ScheduleEntry {
+    id: string;
+    name: string;
+    cron?: string;
+    runAt?: Date;
+    payload: Record<string, unknown>;
+    status: "active" | "paused" | "cancelled" | "completed";
+    createdAt: Date;
+}
+export interface ScheduleBackend {
+    create(entry: {
+        name: string;
+        cron?: string;
+        runAt?: string;
+        payload: Record<string, unknown>;
+    }): Promise<ScheduleEntry>;
+    list(status?: string): Promise<ScheduleEntry[]>;
+    cancel(id: string): Promise<boolean>;
+}
+/**
+ * Create schedule tools backed by the given ScheduleBackend.
+ */
+export declare function createScheduleTools(backend: ScheduleBackend): ToolDefinition[];

package/dist/tools/routers/search-backends.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Search Backends — concrete WebSearchProvider implementations.
+ *
+ * Cascade: Tavily (default) → SearXNG (self-hosted) → DuckDuckGo (fallback).
+ * Configurable per workspace via searchBackend option.
+ */
+import type { WebSearchProvider, WebSearchResult } from "./web-router.js";
+export declare class TavilySearchProvider implements WebSearchProvider {
+    private apiKey;
+    private baseUrl;
+    constructor(opts: {
+        apiKey: string;
+        baseUrl?: string;
+    });
+    search(query: string, opts?: {
+        limit?: number;
+    }): Promise<WebSearchResult[]>;
+}
+export declare class SearXNGSearchProvider implements WebSearchProvider {
+    private baseUrl;
+    constructor(opts: {
+        baseUrl: string;
+    });
+    search(query: string, opts?: {
+        limit?: number;
+    }): Promise<WebSearchResult[]>;
+}
+export declare class DuckDuckGoSearchProvider implements WebSearchProvider {
+    search(query: string, opts?: {
+        limit?: number;
+    }): Promise<WebSearchResult[]>;
+}
+export type SearchBackendType = "tavily" | "searxng" | "duckduckgo";
+export interface SearchBackendConfig {
+    type: SearchBackendType;
+    apiKey?: string;
+    baseUrl?: string;
+}
+/**
+ * Build a primary + fallback search provider pair from config.
+ *
+ * Cascade: configured primary → DuckDuckGo fallback (unless primary IS DDG).
+ */
+export declare function createSearchBackend(config: SearchBackendConfig): {
+    primary: WebSearchProvider;
+    fallback?: WebSearchProvider;
+};

package/dist/tools/routers/task-router.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Task Router — exposes high-level task planning and management as tool definitions.
+ *
+ * Tools: tasks.plan, tasks.update, tasks.list, tasks.complete
+ *
+ * Distinct from builtins/tasks-router.ts which provides low-level CRUD.
+ * This router adds planning, decomposition, and completion semantics.
+ */
+import type { ToolDefinition } from "../registry.js";
+export interface TaskPlan {
+    id: string;
+    goal: string;
+    steps: TaskStep[];
+    status: "planning" | "active" | "completed" | "cancelled";
+    createdAt: number;
+}
+export interface TaskStep {
+    id: string;
+    description: string;
+    status: "pending" | "in_progress" | "done" | "skipped";
+    result?: string;
+}
+export interface TaskPlanBackend {
+    plan(goal: string, context?: string): Promise<TaskPlan>;
+    update(planId: string, stepId: string, status: TaskStep["status"], result?: string): Promise<TaskPlan>;
+    list(status?: TaskPlan["status"]): Promise<TaskPlan[]>;
+    complete(planId: string, summary: string): Promise<TaskPlan>;
+}
+/**
+ * Create task planning tools backed by the given TaskPlanBackend.
+ */
+export declare function createTaskPlanTools(backend: TaskPlanBackend): ToolDefinition[];

package/dist/tools/routers/web-router.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Web Router — exposes web search and fetch as tool definitions.
+ *
+ * Tools: web.search, web.fetch
+ *
+ * Search uses a primary provider (e.g. Tavily) with DuckDuckGo fallback.
+ * Fetch retrieves and extracts content from URLs with SSRF protection.
+ */
+import type { ToolDefinition } from "../registry.js";
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    score?: number;
+}
+export interface WebSearchProvider {
+    search(query: string, opts?: {
+        limit?: number;
+    }): Promise<WebSearchResult[]>;
+}
+export interface WebFetchProvider {
+    fetch(url: string): Promise<{
+        title: string;
+        content: string;
+        url: string;
+    }>;
+}
+export interface WebBackend {
+    primary: WebSearchProvider;
+    fallback?: WebSearchProvider;
+    fetcher: WebFetchProvider;
+}
+/**
+ * Create web tools backed by search and fetch providers.
+ */
+export declare function createWebTools(backend: WebBackend): ToolDefinition[];