@ixo/oracle-runtime-workers 0.2.0

package/src/plugins/editor/standalone-editor-tool.ts

@@ -0,0 +1,200 @@
+/**
+ * `call_editor_agent`: the document surface. One tool for every case — it
+ * targets the document the user has open by default, and any `room_id` the
+ * main agent names, so a page created mid-turn can be written into while
+ * another document is open. Each invocation spins up a short-lived inner agent
+ * over that one document and forwards its tool calls into the parent graph.
+ */
+
+import { tool as lcTool } from '@langchain/core/tools';
+import {
+  HumanMessage,
+  ToolMessage,
+  type BaseMessage,
+} from '@langchain/core/messages';
+import { Command } from '@langchain/langgraph';
+import { createAgent, type StructuredTool } from 'langchain';
+import { z } from 'zod';
+
+import { filterForwardedMessages } from '../../core/subagent-as-tool';
+import { tool as pluginTool } from '../../plugin-api/tool-helper';
+import type { PluginTool, RuntimeContext } from '../../plugin-api/types';
+import { createContentTools } from './content-tools';
+import { buildAppConfig, EDITOR_AGENT_TOOL_NAME } from './editor-agent';
+import type { BlocknoteToolsConfig } from './editor-config';
+import { resolveEditorMatrixClient } from './editor-mx';
+import { noDocument, notAMember } from './failures';
+import { editorAgentPrompt } from './prompts';
+import { isUserInRoom } from './room-membership';
+
+const standaloneEditorSchema = z.object({
+  room_id: z
+    .string()
+    .regex(
+      /^![A-Za-z0-9._=-]+:[A-Za-z0-9.-]+(?::\d+)?$/,
+      'Not a Matrix room id. A real id looks like "!oeGkcJIKNpeSiaGHVE:devmx.ixo.earth" ' +
+        'and only ever comes from a tool result (list_workspace_pages, ' +
+        'create_page_room). Never invent or placeholder one — omit room_id ' +
+        'to target the document the user has open.',
+    )
+    .optional()
+    .describe(
+      'Matrix room ID of the document to read or edit (e.g. ' +
+        '"!oeGkcJIKNpeSiaGHVE:devmx.ixo.earth"). Omit it to target the ' +
+        'document the user currently has open. Pass it to target any other ' +
+        'document — the id returned by create_page_room, or one found with ' +
+        'list_workspace_pages. Never guess it.',
+    ),
+  task: z
+    .string()
+    .min(1)
+    .describe(
+      'A detailed, self-contained instruction. The document assistant has NO ' +
+        'conversation context — this string is all it receives. Include the ' +
+        'objective, block ids, property names, and exact values. Do not put ' +
+        'the room id here.',
+    ),
+});
+
+const STANDALONE_DESCRIPTION =
+  'Content assistant for one document. Targets the document the user has ' +
+  'open by default; pass `room_id` to target any other document, including ' +
+  'one just created with create_page_room. Give it a self-contained `task`: ' +
+  'it reads the document and edits its content (insert, rewrite, reorder, ' +
+  'delete, replace text). It does not create documents, build flows, or run ' +
+  'blocks.';
+
+function lastMessageContent(messages: BaseMessage[]): string {
+  const last = messages.at(-1);
+  if (!last?.content) return '';
+  if (typeof last.content === 'string') return last.content;
+  if (Array.isArray(last.content)) {
+    for (const part of last.content) {
+      if (typeof part !== 'object' || part === null) continue;
+      const record: Record<string, unknown> = part;
+      if (record.type === 'text' && typeof record.text === 'string') {
+        return record.text;
+      }
+    }
+    return '';
+  }
+  return JSON.stringify(last.content);
+}
+
+export interface CreateStandaloneEditorToolOptions {
+  /** Editor config built when the plugin's request tools are resolved. */
+  toolsConfig: BlocknoteToolsConfig;
+}
+
+/**
+ * Bridge the content `PluginTool`s into LangChain tools for the inner agent,
+ * reusing the outer request's `RuntimeContext` rather than rebuilding one.
+ */
+function toStructuredTools(
+  tools: PluginTool[],
+  ctx: RuntimeContext,
+): StructuredTool[] {
+  return tools.map((t) =>
+    lcTool(async (args) => t.handler(args, ctx), {
+      name: t.name,
+      description: t.description,
+      schema: t.schema,
+    }),
+  );
+}
+
+/** The document the client reports as open, when there is one. */
+function readOpenDocument(ctx: RuntimeContext): string | undefined {
+  const value = ctx.history.state.editorRoomId;
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
+export function createStandaloneEditorTool(
+  opts: CreateStandaloneEditorToolOptions,
+): PluginTool {
+  return pluginTool(
+    async (rawArgs, ctx: RuntimeContext) => {
+      const { room_id: explicitRoomId, task } =
+        standaloneEditorSchema.parse(rawArgs);
+      const roomId = explicitRoomId ?? readOpenDocument(ctx);
+      if (!roomId) return JSON.stringify(noDocument());
+
+      // The assistant acts with the oracle's admin identity, so "the user's
+      // documents" must be computed from the *user's* membership — otherwise an
+      // agent could be steered into any room id it is handed. On Workers the
+      // check runs through the gateway Durable Object (ctx.matrix).
+      if (!(await isUserInRoom(ctx, roomId, ctx.user.matrixUserId))) {
+        ctx.logger.warn(
+          `[editor] user ${ctx.user.did} is not a member of ${roomId} — refusing document access`,
+        );
+        return JSON.stringify(notAMember(roomId));
+      }
+
+      try {
+        const matrixClient = await resolveEditorMatrixClient({
+          baseUrl: opts.toolsConfig.matrix.baseUrl,
+          userId: opts.toolsConfig.matrix.userId,
+          accessToken: opts.toolsConfig.matrix.accessToken,
+          matrixClient: opts.toolsConfig.matrixClient,
+        });
+
+        const contentTools = createContentTools({
+          matrixClient,
+          appConfig: buildAppConfig(opts.toolsConfig, {
+            type: 'id',
+            value: roomId,
+          }),
+        });
+        const boundTools = toStructuredTools(contentTools, ctx);
+
+        const agent = createAgent({
+          model: ctx.llm.get('subagent'),
+          tools: boundTools,
+          systemPrompt: editorAgentPrompt,
+          middleware: [],
+        });
+
+        const result = await agent.invoke({
+          messages: [new HumanMessage(task)],
+        });
+        const messages = result.messages as BaseMessage[];
+        const text = lastMessageContent(messages);
+
+        // Forward the inner tool calls + results into the parent graph — the
+        // same mechanism `createSubagentAsTool` uses with `forwardTools` — so
+        // the FE renders document activity inline whichever path handled the
+        // turn. Without a parent tool_call_id there is nothing to attach to.
+        const toolCallId = ctx.toolCallId;
+        if (!toolCallId) return text;
+
+        const forwardSet = new Set(boundTools.map((t) => t.name));
+        const forwarded = filterForwardedMessages(
+          messages,
+          forwardSet,
+          toolCallId,
+        );
+        if (forwarded.length === 0) return text;
+
+        return new Command({
+          update: {
+            messages: [
+              ...forwarded,
+              new ToolMessage({ content: text, tool_call_id: toolCallId }),
+            ],
+          },
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.logger.error(
+          `[editor] standalone failed for ${roomId}: ${message}`,
+        );
+        return `Error opening the document ${roomId}: ${message}`;
+      }
+    },
+    {
+      name: EDITOR_AGENT_TOOL_NAME,
+      description: STANDALONE_DESCRIPTION,
+      schema: standaloneEditorSchema,
+    },
+  );
+}

package/src/plugins/firecrawl/firecrawl-agent.ts

@@ -0,0 +1,93 @@
+import type { PluginSubAgent, PluginTool } from '../../plugin-api/types';
+
+const SHARED_EXPECTATIONS = `
+You are the Firecrawl Agent for this workspace. Your entire job is to perform
+web search and scraping tasks through the Firecrawl MCP tools on behalf of the
+user.
+
+🚨 **API REJECTION RULE**: You are ONLY for scraping human-readable web pages and web search. If the task asks you to fetch data from an API endpoint (any URL containing /api/, /v1/, /v2/, /v3/, returning JSON/XML data, or any REST/GraphQL endpoint), you MUST refuse and reply: "This is an API call — use the Sandbox instead (write a script with fetch/curl/requests). I only handle web pages and web search." Do NOT attempt to scrape API endpoints.
+
+Core expectations:
+- Treat published web content as potentially unreliable—cross-check when you can.
+- Never make HTTP requests directly; always operate through the exposed Firecrawl
+  tools and respect their rate limits.
+- Narrate what you're about to fetch or search, then summarize the findings with
+  citations (URLs) when possible.
+- Call out stale, conflicting, or missing information before acting on it.
+
+Efficiency rules (CRITICAL — you run under a strict time budget):
+- **Search once, search smart.** Write a single, well-crafted search query that
+  targets exactly what you need. Do NOT issue multiple redundant searches hoping
+  for better results.
+- **One source is enough when the data is clear.** For factual lookups (prices,
+  weather, scores, exchange rates), use ONE authoritative result. Do not scrape
+  multiple sites to cross-verify commodity prices or similar public data.
+- **Prefer search over scrape.** \`firecrawl_search\` returns snippets directly —
+  use it first. Only fall back to \`firecrawl_scrape\` when you need full-page
+  content that search snippets can't provide (e.g., full articles, tables).
+- **Never crawl entire sites.** If a search gives you the answer, stop. Do not
+  follow links to "learn more" or scrape additional pages for context.
+- **Fail fast.** If a search returns no useful results on the first try, report
+  what you found (or didn't) and stop. Do NOT rephrase and retry endlessly.
+- **Total tool calls budget: max 3.** You should almost always finish in 1-2 tool
+  calls. If you've made 3 calls, wrap up with whatever you have.
+
+Task discipline:
+- You are a sub-agent invoked by the main agent. You receive a single task message — that is ALL the context you have.
+- If the task is unclear, ambiguous, or missing critical details (IDs, names, scope, what to do), do NOT guess. Instead, STOP immediately and return a clear message explaining what information you need. The main agent will ask the user and re-invoke you with a complete task.
+- Never loop or retry the same failing approach. If something fails twice, return the error and stop.
+- Complete the requested task and STOP. Do not do additional unrequested work.
+`.trim();
+
+const WORKFLOW_GUIDELINES = `
+### Workflow
+1. Identify the single most important piece of information the task needs.
+2. Write ONE precise search query (e.g., "gold spot price USD today" — not
+   "gold price" then "gold market" then "gold value per ounce").
+3. If the search result contains the answer, extract it and STOP.
+4. Only scrape a URL if the search snippet was incomplete and you need the full page.
+5. Return findings with citations. If data is unavailable, say so — don't keep searching.
+`.trim();
+
+const formatToolDocs = (tools: PluginTool[]): string => {
+  if (!tools.length) {
+    return '- No Firecrawl tools are currently configured.';
+  }
+
+  return tools
+    .map((t) => {
+      const description = t.description?.trim() ?? 'No description provided.';
+      return `Firecrawl Agent: \`${t.name}\`: ${description}`;
+    })
+    .join('\n');
+};
+
+const buildFirecrawlPrompt = (tools: PluginTool[]): string =>
+  `
+${SHARED_EXPECTATIONS}
+
+### Available Firecrawl Tools
+${formatToolDocs(tools)}
+
+${WORKFLOW_GUIDELINES}
+`.trim();
+
+const buildFirecrawlDescription = (tools: PluginTool[]): string => {
+  const names = tools.map((t) => t.name).join(', ') || 'no tools configured';
+  return `Firecrawl Agent for web search & scraping human-readable web pages via (${names}). NOT for API calls — use the Sandbox for APIs (fetch/curl/requests).`;
+};
+
+/**
+ * Build the Firecrawl sub-agent definition. Tools are supplied by the
+ * plugin and close over a `MultiServerMCPClient` keyed to `FIRECRAWL_MCP_URL`.
+ */
+export function createFirecrawlSubAgent(tools: PluginTool[]): PluginSubAgent {
+  return {
+    name: 'Firecrawl Agent',
+    description: buildFirecrawlDescription(tools),
+    systemPrompt: buildFirecrawlPrompt(tools),
+    tools,
+    model: 'subagent',
+    middlewares: [],
+  };
+}

package/src/plugins/firecrawl/firecrawl-tools.ts

@@ -0,0 +1,220 @@
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import { withCallTimeout } from '../mcp-call-timeout';
+
+/** Our own per-call limit (never given to the SDK — see `mcp-call-timeout.ts`). */
+const FIRECRAWL_TOOL_TIMEOUT_MS = 120_000;
+import { z } from 'zod';
+import { tool } from '../../plugin-api/tool-helper';
+import type { PluginTool } from '../../plugin-api/types';
+
+/**
+ * Minimal surface a Firecrawl MCP tool needs to expose to be proxied: an
+ * identifier and an `invoke` method. `MultiServerMCPClient.getTools()`
+ * returns `DynamicStructuredTool[]` which trivially satisfies this shape,
+ * and unit tests can satisfy it with a plain object — no SDK ceremony.
+ */
+export interface FirecrawlMcpProxyTool {
+  name: string;
+  invoke: (input: unknown) => Promise<unknown>;
+}
+
+/**
+ * Tool names that the upstream Firecrawl MCP server exposes (prefixed with
+ * the server name configured in {@link MultiServerMCPClient}). Filtering by
+ * these names keeps the agent's surface area tight even if the server adds
+ * extra capabilities later.
+ */
+export const FIRECRAWL_SCRAPE_MCP_NAME = 'firecrawl__firecrawl_scrape';
+export const FIRECRAWL_SEARCH_MCP_NAME = 'firecrawl__firecrawl_search';
+
+/** Public tool names shown to the agent (server prefix dropped). */
+export const FIRECRAWL_SCRAPE_TOOL = 'firecrawl_scrape';
+export const FIRECRAWL_SEARCH_TOOL = 'firecrawl_search';
+
+const SEARCH_DESCRIPTION = `Web search via Firecrawl. Returns a ranked list of result snippets with titles and URLs.
+
+Use this BEFORE \`firecrawl_scrape\` whenever a search snippet is enough — it's faster and cheaper. Only escalate to scraping when the snippet is incomplete and you need the full page.
+
+🚨 Never use this for API endpoints (any URL with /api/, /v1/, /v2/, /v3/, or returning JSON/XML). Use the Sandbox for those.`;
+
+const SCRAPE_DESCRIPTION = `Scrape a single human-readable web page via Firecrawl. Returns the page as Markdown plus structured metadata.
+
+Use this only when you've already tried \`firecrawl_search\` and need the full page content (long article, table, structured data on a static page).
+
+🚨 Never use this on API endpoints (any URL with /api/, /v1/, /v2/, /v3/, or returning JSON/XML). Use the Sandbox for those.`;
+
+const searchSchema = z.object({
+  query: z
+    .string()
+    .min(1, 'Query is required and cannot be empty.')
+    .describe('Search query — write ONE precise, well-targeted query.'),
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(10)
+    .optional()
+    .describe('Max number of results (1-10). Default upstream.'),
+});
+
+const scrapeSchema = z.object({
+  url: z
+    .string()
+    .url()
+    .describe('Fully-qualified URL of the page to scrape (https://...).'),
+  formats: z
+    .array(z.enum(['markdown', 'html', 'rawHtml', 'links', 'screenshot']))
+    .optional()
+    .describe(
+      "Output formats. Defaults to ['markdown']. Use 'links' to enumerate outbound URLs.",
+    ),
+  onlyMainContent: z
+    .boolean()
+    .optional()
+    .describe(
+      'When true (default), strips navigation, ads, and boilerplate — returns just the main content block.',
+    ),
+});
+
+/**
+ * Factory for the underlying MCP-tool list. Injectable so unit tests can
+ * substitute a stub without spinning up the real MCP transport.
+ */
+export type FirecrawlMcpFactory = () => Promise<FirecrawlMcpProxyTool[]>;
+
+/**
+ * Build the default factory keyed to `FIRECRAWL_MCP_URL`.
+ *
+ * No client outlives a call: the streamable-HTTP transport keeps a
+ * server→client stream open for as long as the client exists, and a client
+ * cached for the object's lifetime (the previous shape, with `reconnect`)
+ * left the user's Durable Object permanently resident — never hibernating,
+ * billed around the clock. Each invocation connects, calls, and closes; the
+ * upstream tool names are fixed, so nothing needs discovering up front.
+ */
+export function createDefaultFirecrawlMcpFactory(
+  firecrawlUrl: string,
+): FirecrawlMcpFactory {
+  const withClient = async <T>(
+    run: (tools: FirecrawlMcpProxyTool[]) => Promise<T>,
+  ): Promise<T> => {
+    const client = new MultiServerMCPClient({
+      useStandardContentBlocks: true,
+      prefixToolNameWithServerName: true,
+      mcpServers: {
+        firecrawl: {
+          type: 'http',
+          transport: 'http',
+          url: firecrawlUrl,
+        },
+      },
+    });
+    try {
+      const all = await client.getTools();
+      return await run(
+        all.filter(
+          (t) =>
+            t.name === FIRECRAWL_SCRAPE_MCP_NAME ||
+            t.name === FIRECRAWL_SEARCH_MCP_NAME,
+        ),
+      );
+    } finally {
+      await client.close().catch(() => undefined);
+    }
+  };
+  const proxy = (name: string): FirecrawlMcpProxyTool => ({
+    name,
+    invoke: (input) =>
+      withClient(async (tools) => {
+        const target = tools.find((t) => t.name === name);
+        if (!target) {
+          throw new Error(
+            `upstream MCP tool "${name}" is not exposed by the configured Firecrawl server.`,
+          );
+        }
+        return withCallTimeout(
+          () => target.invoke(input),
+          FIRECRAWL_TOOL_TIMEOUT_MS,
+          name,
+        );
+      }),
+  });
+  const tools = [
+    proxy(FIRECRAWL_SCRAPE_MCP_NAME),
+    proxy(FIRECRAWL_SEARCH_MCP_NAME),
+  ];
+  return async () => tools;
+}
+
+interface ProxyHandlerArgs {
+  factory: FirecrawlMcpFactory;
+  mcpToolName: string;
+  publicToolName: string;
+}
+
+/**
+ * Build a handler that proxies a validated input through the MCP client.
+ * The underlying tool is resolved lazily on the first call and cached.
+ */
+function buildProxyHandler({
+  factory,
+  mcpToolName,
+  publicToolName,
+}: ProxyHandlerArgs): (args: unknown) => Promise<unknown> {
+  return async (args) => {
+    const mcpTools = await factory();
+    const target = mcpTools.find((t) => t.name === mcpToolName);
+    if (!target) {
+      throw new Error(
+        `${publicToolName}: upstream MCP tool "${mcpToolName}" is not exposed by the configured Firecrawl server.`,
+      );
+    }
+    return target.invoke(args);
+  };
+}
+
+/**
+ * Construct the two Firecrawl plugin tools. Each tool's handler proxies
+ * the validated input into the upstream MCP server using the supplied
+ * factory. Schemas are declared statically so the agent sees a stable
+ * tool surface even before the first MCP fetch.
+ */
+export function createFirecrawlTools(
+  factory: FirecrawlMcpFactory,
+): PluginTool[] {
+  const search = tool(
+    async (rawArgs) => {
+      const parsed = searchSchema.parse(rawArgs);
+      const handler = buildProxyHandler({
+        factory,
+        mcpToolName: FIRECRAWL_SEARCH_MCP_NAME,
+        publicToolName: FIRECRAWL_SEARCH_TOOL,
+      });
+      return handler(parsed);
+    },
+    {
+      name: FIRECRAWL_SEARCH_TOOL,
+      description: SEARCH_DESCRIPTION,
+      schema: searchSchema,
+    },
+  );
+
+  const scrape = tool(
+    async (rawArgs) => {
+      const parsed = scrapeSchema.parse(rawArgs);
+      const handler = buildProxyHandler({
+        factory,
+        mcpToolName: FIRECRAWL_SCRAPE_MCP_NAME,
+        publicToolName: FIRECRAWL_SCRAPE_TOOL,
+      });
+      return handler(parsed);
+    },
+    {
+      name: FIRECRAWL_SCRAPE_TOOL,
+      description: SCRAPE_DESCRIPTION,
+      schema: scrapeSchema,
+    },
+  );
+
+  return [search, scrape];
+}

package/src/plugins/firecrawl/firecrawl.plugin.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { OraclePlugin, type PluginEnv } from '../../plugin-api/oracle-plugin';
+import type {
+  MergedConfig,
+  PluginContext,
+  PluginManifest,
+  PluginSubAgent,
+} from '../../plugin-api/types';
+import { createFirecrawlSubAgent } from './firecrawl-agent';
+import {
+  createDefaultFirecrawlMcpFactory,
+  createFirecrawlTools,
+  type FirecrawlMcpFactory,
+} from './firecrawl-tools';
+
+const configSchema = z.object({
+  FIRECRAWL_MCP_URL: z
+    .string()
+    .url('FIRECRAWL_MCP_URL must be a valid HTTP(S) URL.'),
+});
+
+const manifest: PluginManifest = {
+  title: 'Firecrawl',
+  summary: 'Web search and scraping of human-readable pages via Firecrawl.',
+  whenToUse: [
+    'User asks the agent to search the web for current information.',
+    'User wants the contents of a specific page summarized or extracted.',
+    'A question can only be answered by recent public web content.',
+  ],
+  whenNotToUse: [
+    'Fetching from an API endpoint (URLs containing /api/, /v1/, /v2/, /v3/, or that return JSON/XML) — use the Sandbox instead.',
+    'IXO entity lookups (use the Domain Indexer).',
+    'Personal memory or past-conversation recall (use Memory).',
+  ],
+  examples: [
+    {
+      user: 'What did OpenAI announce at their last event?',
+      thought:
+        'Recent public web content — delegate to call_firecrawl_agent for a fresh search.',
+      tool: 'call_firecrawl_agent',
+    },
+    {
+      user: 'Pull the key points from this page: https://example.com/blog/post',
+      thought: 'Specific human-readable page — scrape it, summarize.',
+      tool: 'call_firecrawl_agent',
+    },
+  ],
+  tags: ['web', 'search', 'scrape', 'firecrawl'],
+  category: 'data',
+  visibility: 'on-demand',
+  stability: 'stable',
+};
+
+function resolveFirecrawlUrl(config: MergedConfig): string {
+  const parsed = configSchema.parse(config);
+  return parsed.FIRECRAWL_MCP_URL;
+}
+
+/** Optional dependency injection — primarily for tests. */
+export interface FirecrawlPluginOptions {
+  /**
+   * Override the MCP-tools factory. Defaults to a Firecrawl-MCP HTTP client
+   * built from `FIRECRAWL_MCP_URL`. Tests pass a stub so the plugin never
+   * touches the network.
+   */
+  mcpFactory?: (firecrawlUrl: string) => FirecrawlMcpFactory;
+}
+
+/**
+ * Firecrawl plugin. Exposes a sub-agent (`call_firecrawl_agent`) that wraps
+ * the upstream Firecrawl MCP server's `firecrawl_search` and
+ * `firecrawl_scrape` tools.
+ */
+export class FirecrawlPlugin extends OraclePlugin {
+  readonly name = 'firecrawl';
+
+  readonly version = '1.0.0';
+
+  readonly manifest = manifest;
+
+  override readonly configSchema = configSchema;
+
+  override readonly autoDetectHint = 'FIRECRAWL_MCP_URL';
+
+  private readonly mcpFactory: (firecrawlUrl: string) => FirecrawlMcpFactory;
+
+  constructor(options: FirecrawlPluginOptions = {}) {
+    super();
+    this.mcpFactory = options.mcpFactory ?? createDefaultFirecrawlMcpFactory;
+  }
+
+  override autoDetect(env: PluginEnv): boolean {
+    return (
+      typeof env.FIRECRAWL_MCP_URL === 'string' &&
+      env.FIRECRAWL_MCP_URL.length > 0
+    );
+  }
+
+  override getSubAgents(ctx: PluginContext): PluginSubAgent[] {
+    const firecrawlUrl = resolveFirecrawlUrl(ctx.config);
+    const factory = this.mcpFactory(firecrawlUrl);
+    const tools = createFirecrawlTools(factory);
+    return [createFirecrawlSubAgent(tools)];
+  }
+}

package/src/plugins/firecrawl/index.ts

@@ -0,0 +1,15 @@
+export { createFirecrawlSubAgent } from './firecrawl-agent';
+export {
+  createDefaultFirecrawlMcpFactory,
+  createFirecrawlTools,
+  FIRECRAWL_SCRAPE_MCP_NAME,
+  FIRECRAWL_SCRAPE_TOOL,
+  FIRECRAWL_SEARCH_MCP_NAME,
+  FIRECRAWL_SEARCH_TOOL,
+  type FirecrawlMcpFactory,
+  type FirecrawlMcpProxyTool,
+} from './firecrawl-tools';
+export {
+  FirecrawlPlugin,
+  type FirecrawlPluginOptions,
+} from './firecrawl.plugin';