@opencraw/mcp 0.1.45 → 0.1.48

package/dist/index.esm.js

@@ -3,6 +3,11 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { readRecordsFile, diffRecords, memorySink, fileSink, createCrawler, RecipeSet, RecipeValidationError, RecipeBindingError, parseOutputRecipe, parseInputRecipe, bindRecipeSet } from '@opencraw/core';
 import { diffReport, readRecipeFiles, probeUrl, loadForRun, loadPlugins, resolveAccess } from '@opencraw/cli';
 import { z } from 'zod';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
 
 /** Changes returned at most; the counts cover all of them. */
 const CHANGE_LIMIT = 200;
@@ -56,6 +61,191 @@ async function diffTool(args) {
   }
 }
 
+/**
+ * The topic id of a documentation file: its path under the docs folder, without the extension and with forward slashes, so `recipes/authoring.md` is
+ * `recipes/authoring`.
+ *
+ * @param relativePath - The file's path under the docs folder.
+ * @returns The id.
+ */
+function topicIdOf(relativePath) {
+  return relativePath.replaceAll('\\', '/').replace(/\.md$/i, '');
+}
+/**
+ * The title of a document: its first top-level heading, else its id.
+ *
+ * @param markdown - The document.
+ * @param fallback - The id, when there is no heading.
+ * @returns The title.
+ */
+function titleOf(markdown, fallback) {
+  const heading = outlineOf(markdown).find(candidate => candidate.level === 1);
+  return heading?.text ?? fallback;
+}
+/**
+ * Every heading of a Markdown document, in order. A line inside a fenced code block is not a heading (a shell comment starts with `#` too).
+ *
+ * @param markdown - The document.
+ * @returns The headings.
+ */
+function outlineOf(markdown) {
+  const headings = [];
+  let fence;
+  for (const [line, text] of markdown.split(/\r?\n/).entries()) {
+    const marker = /^\s*(`{3,}|~{3,})/.exec(text)?.[1];
+    if (marker !== undefined) {
+      if (fence === undefined) fence = marker[0];else if (marker[0] === fence) fence = undefined;
+      continue;
+    }
+    if (fence !== undefined) continue;
+    const match = /^(#{1,6}) (.+)$/.exec(text);
+    if (match !== null) headings.push({
+      level: match[1].length,
+      text: match[2].trim().replace(/ #+$/, ''),
+      line
+    });
+  }
+  return headings;
+}
+/**
+ * One section of a document: from the heading whose text contains `heading` (case-insensitive; an exact match wins over a partial one) to the next
+ * heading of the same or a higher level, so its subsections come with it.
+ *
+ * @param markdown - The document.
+ * @param heading - What the heading says, or part of it.
+ * @returns The section's text, or `undefined` when no heading matches.
+ */
+function sectionOf(markdown, heading) {
+  const wanted = heading.trim().toLowerCase();
+  const headings = outlineOf(markdown);
+  const start = headings.find(candidate => candidate.text.toLowerCase() === wanted) ?? headings.find(candidate => candidate.text.toLowerCase().includes(wanted));
+  if (start === undefined) return undefined;
+  const end = headings.find(candidate => candidate.line > start.line && candidate.level <= start.level);
+  const lines = markdown.split(/\r?\n/);
+  return lines.slice(start.line, end?.line ?? lines.length).join('\n').trim();
+}
+
+/** The folders under the docs folder whose Markdown files are documentation for a person (or an agent) using OpenCraw. */
+const FOLDERS = ['recipes', 'how-it-works', 'studio'];
+/**
+ * The documents under a docs folder: the Markdown files directly inside `recipes`, `how-it-works` and `studio` (their pictures and capture scripts are
+ * not documentation to read).
+ *
+ * @param root - The docs folder.
+ * @returns The topics, ordered by id.
+ */
+async function listTopics(root) {
+  const topics = [];
+  for (const folder of FOLDERS) {
+    let names;
+    try {
+      names = await readdir(join(root, folder));
+    } catch {
+      continue;
+    }
+    const documents = names.filter(file => file.toLowerCase().endsWith('.md'));
+    for (const name of documents) {
+      const id = topicIdOf(`${folder}/${name}`);
+      const text = await readFile(join(root, folder, name), 'utf8');
+      topics.push({
+        id,
+        title: titleOf(text, id),
+        size: text.length
+      });
+    }
+  }
+  return topics.sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * One document's text.
+ *
+ * @param root - The docs folder.
+ * @param id - The topic id from `listTopics` (never a path: nothing outside the listed folders is read).
+ * @returns The Markdown, or `undefined` when there is no such topic.
+ */
+async function readTopic(root, id) {
+  const known = await listTopics(root);
+  if (known.every(topic => topic.id !== id)) return undefined;
+  return await readFile(join(root, `${id}.md`), 'utf8');
+}
+
+/** Input schema for the `docs` tool. */
+const docsInputShape = {
+  topic: z.string().optional().describe('A document id from the list this tool returns without a topic (`recipes/authoring`, `how-it-works/06-documents`, `studio/manual`…). Leave out to list every document.'),
+  section: z.string().optional().describe('A heading (or part of one) of that document: only that section comes back, subsections included. A long document answers with its outline until you ask for a section.')
+};
+/** A document longer than this many characters comes back as its outline, and the section asked for. */
+const WHOLE_DOCUMENT_LIMIT = 30_000;
+function text$1(value, isError = false) {
+  return {
+    content: [{
+      type: 'text',
+      text: typeof value === 'string' ? value : JSON.stringify(value)
+    }],
+    ...(isError && {
+      isError
+    }),
+    ...(typeof value === 'object' && value !== null && {
+      structuredContent: value
+    })
+  };
+}
+/**
+ * The `docs` tool: OpenCraw's own documentation, for an agent that has to write recipes right: the authoring guide (every step, selector, transform
+ * and policy), how it all works, the examples and the Studio manual. Without a topic it lists what there is; with one it gives the document, or just
+ * the section asked for, so a long guide costs only what is read.
+ *
+ * @param args - The tool's parsed input.
+ * @param root - The docs folder (the packaged copy, or the repository's).
+ * @returns The MCP tool result.
+ */
+async function docsTool(args, root) {
+  const topics = await listTopics(root);
+  if (topics.length === 0) return text$1('The documentation is not installed with this server.', true);
+  if (args.topic === undefined) return text$1({
+    topics,
+    hint: 'Ask for one with { topic }, and for part of a long one with { topic, section }.'
+  });
+  const document = await readTopic(root, args.topic);
+  if (document === undefined) {
+    const close = topics.filter(topic => topic.id.includes(args.topic?.toLowerCase() ?? '') || args.topic?.includes(topic.id) === true).map(topic => topic.id);
+    return text$1(`There is no document "${args.topic}". ${close.length > 0 ? `Did you mean: ${close.join(', ')}?` : `The documents are: ${topics.map(topic => topic.id).join(', ')}.`}`, true);
+  }
+  if (args.section !== undefined) {
+    const section = sectionOf(document, args.section);
+    return section === undefined ? text$1({
+      topic: args.topic,
+      error: `no heading contains "${args.section}"`,
+      outline: outlineOf(document).map(heading => `${'#'.repeat(heading.level)} ${heading.text}`)
+    }, true) : text$1({
+      topic: args.topic,
+      section: args.section,
+      text: section
+    });
+  }
+  if (document.length <= WHOLE_DOCUMENT_LIMIT) return text$1({
+    topic: args.topic,
+    text: document
+  });
+  return text$1({
+    topic: args.topic,
+    outline: outlineOf(document).map(heading => `${'#'.repeat(heading.level)} ${heading.text}`),
+    note: `This document is ${String(document.length)} characters: ask for a section with { topic, section } using a heading from the outline.`
+  });
+}
+
+/**
+ * Where the documentation is: a `docs` folder beside `dist` in the installed package (copied there at build), or the repository's own `docs` when the server runs
+ * from a checkout.
+ *
+ * @returns The docs folder.
+ */
+function docsRoot() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join(here, '..', 'docs'), join(here, '..', '..', '..', 'docs')];
+  return candidates.find(candidate => existsSync(join(candidate, 'recipes'))) ?? candidates[0];
+}
+
 /** Input schema for the `list_recipes` tool. */
 const listRecipesInputShape = {
   dir: z.string().describe('A directory of recipe files.')
@@ -308,6 +498,312 @@ function loadErrorText(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+/**
+ * Sends one command to a running Studio (`POST /api/command`, the same door its own page uses) and reads the answer.
+ *
+ * @param instance - The Studio to talk to.
+ * @param command - A command `@opencraw/studio`'s `studioCommandSchema` accepts.
+ * @returns The JSON the Studio answered.
+ * @throws Error with the Studio's own message when it refuses.
+ */
+async function sendStudioCommand(instance, command) {
+  const response = await fetch(`${instance.url}/api/command`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-opencraw-token': instance.token
+    },
+    body: JSON.stringify(command)
+  });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error ?? `Studio answered ${String(response.status)}`);
+  return body;
+}
+
+/** Where running Studios announce themselves. */
+function instancesDirectory() {
+  return join(homedir(), '.opencraw', 'studio');
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: the process exists but is not ours to signal.
+    return error.code === 'EPERM';
+  }
+}
+function instanceOf(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value.pid === 'number' && typeof value.url === 'string' && typeof value.token === 'string' && typeof value.startedAt === 'string' ? {
+      pid: value.pid,
+      url: value.url,
+      token: value.token,
+      folder: value.folder,
+      startedAt: value.startedAt
+    } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+/** The announcement files in a directory; none when it does not exist yet. */
+async function namesIn(directory) {
+  try {
+    const names = await readdir(directory);
+    return names.filter(file => file.endsWith('.json'));
+  } catch {
+    return [];
+  }
+}
+/** A file's text; empty when it vanished (its Studio just stopped). */
+async function textOf(file) {
+  try {
+    return await readFile(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+/**
+ * The Studios running on this machine, the newest first. A file whose process is gone (Studio was killed
+ * and could not withdraw it) is left out.
+ *
+ * @param directory - Where Studios announce themselves.
+ * @returns The live Studios.
+ */
+async function runningStudios(directory = instancesDirectory()) {
+  const found = [];
+  const names = await namesIn(directory);
+  for (const name of names) {
+    const instance = instanceOf(await textOf(join(directory, name)));
+    if (instance !== undefined && isAlive(instance.pid)) found.push(instance);
+  }
+  return found.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+
+/** Input schema for `studio_status`: nothing. */
+const studioStatusInputShape = {};
+/** Input schema for `studio_open_recipe`. */
+const studioOpenRecipeInputShape = {
+  path: z.string().min(1).describe('A recipe file (`*.input.json` / `*.ocw-in.json`), a folder of recipes, or a document, as an absolute path.'),
+  workspace: z.string().optional().describe('The folder a document belongs to, when `path` is a document.')
+};
+/** Input schema for `studio_pick`. */
+const studioPickInputShape = {
+  recipeId: z.string().min(1).describe('The id of an input recipe whose start point is a web page, in the folder Studio has open.'),
+  selector: z.string().optional().describe('A CSS selector of the element to pick on the page of the recipe. Give this or `text`.'),
+  text: z.string().optional().describe('The text the element shows, when you do not know a selector: the smallest element showing it is picked.'),
+  add: z.boolean().optional().describe('Add the pick to the recipe straight away (default: leave it staged, for the person to choose a selector and press Add to recipe).')
+};
+/** Input schema for `studio_run_sample`. */
+const studioRunSampleInputShape = {
+  recipeId: z.string().min(1).describe('The id of an input recipe in the folder Studio has open.'),
+  maxRecords: z.number().int().positive().optional().describe('Stop after this many records. Default 10.'),
+  waitSeconds: z.number().int().positive().max(300).optional().describe('How long to wait for the run to finish before answering that it is still running. Default 60.')
+};
+const NO_STUDIO = 'No Studio is running. Start one with `opencraw studio <folder>`, or open a recipe from the OpenCraw view in VS Code ("Open in Studio"), then ask again.';
+const POLL_MS = 500;
+/** How long a page gets to say how a request went. */
+const REPORT_WAIT_MS = 30_000;
+function text(value, isError = false) {
+  return {
+    content: [{
+      type: 'text',
+      text: typeof value === 'string' ? value : JSON.stringify(value)
+    }],
+    ...(isError && {
+      isError
+    }),
+    ...(typeof value === 'object' && value !== null && {
+      structuredContent: value
+    })
+  };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function studioOf(directory) {
+  const [newest] = await runningStudios(directory);
+  return newest;
+}
+/**
+ * `studio_status`: whether a Studio is running, which folder it has open, how many pages are watching and what it is running.
+ *
+ * @param directory - Where Studios announce themselves; the default is the user's own.
+ * @returns The MCP tool result.
+ */
+async function studioStatusTool(directory) {
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text({
+    running: false,
+    hint: NO_STUDIO
+  });
+  try {
+    const status = await sendStudioCommand(studio, {
+      type: 'studio-status'
+    });
+    return text({
+      running: true,
+      url: studio.url,
+      ...status
+    });
+  } catch (error) {
+    return text(`Studio did not answer: ${messageOf(error)}`, true);
+  }
+}
+function sleep(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+/** Asks the open page to do something and waits for what it reports. */
+async function askPage(studio, request, waitMs = REPORT_WAIT_MS) {
+  const {
+    pages,
+    requestId
+  } = await sendStudioCommand(studio, {
+    type: 'ask-ui',
+    request
+  });
+  if (pages === 0) return {
+    pages
+  };
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    const outcome = await sendStudioCommand(studio, {
+      type: 'ui-outcome',
+      requestId
+    });
+    if (outcome.state === 'done') return {
+      pages,
+      outcome: {
+        ok: outcome.ok === true,
+        message: outcome.message ?? '',
+        detail: outcome.detail
+      }
+    };
+    await sleep(POLL_MS / 5);
+  }
+  return {
+    pages
+  };
+}
+const NO_PAGE = 'Studio is running but no page is open on it. Ask the person to open Studio in their browser.';
+const NO_REPORT = 'The page did not answer in time. Is the recipe in the folder Studio has open?';
+/**
+ * `studio_open_recipe`: opens a recipe, a folder or a document in the Studio the person is looking at, so they watch the work happen.
+ *
+ * @param args - What to open.
+ * @param directory - Where Studios announce themselves.
+ * @returns The MCP tool result.
+ */
+async function studioOpenRecipeTool(args, directory) {
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text(NO_STUDIO, true);
+  try {
+    const answer = await askPage(studio, {
+      kind: 'open',
+      path: args.path,
+      workspace: args.workspace
+    });
+    if (answer.pages === 0) return text({
+      opened: false,
+      hint: NO_PAGE,
+      url: studio.url
+    });
+    if (answer.outcome === undefined) return text({
+      opened: false,
+      hint: NO_REPORT
+    });
+    return text({
+      opened: answer.outcome.ok,
+      message: answer.outcome.message
+    }, !answer.outcome.ok);
+  } catch (error) {
+    return text(`Studio refused: ${messageOf(error)}`, true);
+  }
+}
+/**
+ * `studio_pick`: picks a value on a recipe's web page in the Studio the person is looking at, as a click would: they see it selected and the
+ * ways to reach it. With `add` it is added to the recipe. Answers with the selector Studio chose and the others it offers.
+ *
+ * @param args - The recipe and what to pick (a selector or the text shown), and whether to add it.
+ * @param directory - Where Studios announce themselves.
+ * @returns The MCP tool result.
+ */
+async function studioPickTool(args, directory) {
+  if (args.selector === undefined && args.text === undefined) return text('Give a CSS selector or the text the element shows.', true);
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text(NO_STUDIO, true);
+  try {
+    const answer = await askPage(studio, {
+      kind: 'pick',
+      recipeId: args.recipeId,
+      selector: args.selector,
+      text: args.text,
+      add: args.add
+    });
+    if (answer.pages === 0) return text({
+      picked: false,
+      hint: NO_PAGE,
+      url: studio.url
+    }, true);
+    if (answer.outcome === undefined) return text({
+      picked: false,
+      hint: NO_REPORT
+    }, true);
+    return text({
+      picked: answer.outcome.ok,
+      message: answer.outcome.message,
+      ...answer.outcome.detail
+    }, !answer.outcome.ok);
+  } catch (error) {
+    return text(`Studio refused: ${messageOf(error)}`, true);
+  }
+}
+/**
+ * `studio_run_sample`: runs an input recipe as a sample in Studio (the person sees the records arrive), waits for it, and returns the
+ * counts and the first records.
+ *
+ * @param args - The recipe, how many records to stop at and how long to wait.
+ * @param directory - Where Studios announce themselves.
+ * @returns The MCP tool result.
+ */
+async function studioRunSampleTool(args, directory) {
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text(NO_STUDIO, true);
+  try {
+    const {
+      folder
+    } = await sendStudioCommand(studio, {
+      type: 'studio-status'
+    });
+    if (folder === undefined) return text('Studio has no folder open yet. Call studio_open_recipe with a recipe file or a folder first.', true);
+    await sendStudioCommand(studio, {
+      type: 'run-sample',
+      recipeId: args.recipeId,
+      budget: {
+        maxRecords: args.maxRecords ?? 10
+      }
+    });
+    const deadline = Date.now() + (args.waitSeconds ?? 60) * 1000;
+    for (;;) {
+      const status = await sendStudioCommand(studio, {
+        type: 'run-status',
+        recipeId: args.recipeId
+      });
+      if (status.state !== 'running') return text(status);
+      if (Date.now() >= deadline) return text({
+        ...status,
+        hint: 'Still running; ask again with studio_run_sample or look in Studio.'
+      });
+      await sleep(POLL_MS);
+    }
+  } catch (error) {
+    return text(`Studio could not run it: ${messageOf(error)}`, true);
+  }
+}
+
 /** Input schema for the `validate` tool. */
 const validateInputShape = recipeSourceShape;
 /**
@@ -408,7 +904,7 @@ const SERVER_INFO = {
 };
 /**
  * Builds the MCP server: one tool per crawl primitive (`probe`, `validate`,
- * `run`, `list_recipes`, `diff`), each a thin wrapper over `@opencraw/core` and
+ * `run`, `list_recipes`, `diff`), `docs` and the `studio_` tools that drive a running Studio, each a thin wrapper over `@opencraw/core` and
  * `@opencraw/cli`'s structured helpers. No transport is attached; `main`
  * connects it over stdio.
  *
@@ -436,6 +932,26 @@ function createServer() {
     description: 'Compare two runs\' JSON Lines files by record key: what was added, removed, and changed (each field before and after). Use to report what changed in a source since the last crawl.',
     inputSchema: diffInputShape
   }, args => diffTool(args));
+  server.registerTool('docs', {
+    description: 'OpenCraw\'s own documentation: the authoring guide (every step, selector, transform and policy), how it works, the examples and the Studio manual. Without a topic it lists the documents; with one it gives the document, or just a section of it. Read the guide before writing a recipe you are not sure of, instead of guessing.',
+    inputSchema: docsInputShape
+  }, args => docsTool(args, docsRoot()));
+  server.registerTool('studio_status', {
+    description: 'Whether OpenCraw Studio is running on this machine, which folder it has open, how many pages are watching and which recipe it is sampling. Call it before the other studio_ tools.',
+    inputSchema: studioStatusInputShape
+  }, () => studioStatusTool());
+  server.registerTool('studio_open_recipe', {
+    description: 'Open a recipe, a folder of recipes or a document in the Studio the person has open, so they watch the recipe being built. Does nothing to the files.',
+    inputSchema: studioOpenRecipeInputShape
+  }, args => studioOpenRecipeTool(args));
+  server.registerTool('studio_pick', {
+    description: 'Pick a value on the web page of an input recipe in Studio, as a click would: give a CSS selector or the text the element shows. The person sees it selected and the ways to reach it; with add it is added to the recipe. Returns the selector chosen and the alternatives, with how many elements each matches. Open the recipe first with studio_open_recipe.',
+    inputSchema: studioPickInputShape
+  }, args => studioPickTool(args));
+  server.registerTool('studio_run_sample', {
+    description: 'Run an input recipe as a sample in Studio (the person sees the records arrive) and get back the counts, the first records and what was rejected. Studio must have the folder of that recipe open: call studio_open_recipe first.',
+    inputSchema: studioRunSampleInputShape
+  }, args => studioRunSampleTool(args));
   return server;
 }
 

package/dist/list-tool/index.d.ts

@@ -0,0 +1,3 @@
+export { listRecipesTool, listRecipesInputShape } from './list-recipes-tool.handler';
+export type { ListRecipesResult } from './list-recipes-tool.handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/list-tool/list-recipes-tool.handler.d.ts

@@ -0,0 +1,32 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+/** Input schema for the `list_recipes` tool. */
+export declare const listRecipesInputShape: {
+    dir: z.ZodString;
+};
+/** What the `list_recipes` tool returns. */
+export interface ListRecipesResult {
+    outputs: {
+        path: string;
+        id?: string;
+    }[];
+    inputs: {
+        path: string;
+        id?: string;
+        output?: string;
+        mode?: string;
+    }[];
+    others: string[];
+}
+/**
+ * The `list_recipes` tool: what recipes already exist in a directory, cheaper
+ * than a full `validate` call, so an agent can check before writing a new one
+ * or find what an existing output recipe already covers.
+ *
+ * @param args - The tool's parsed input.
+ * @returns The MCP tool result.
+ */
+export declare function listRecipesTool(args: {
+    dir: string;
+}): Promise<CallToolResult>;
+//# sourceMappingURL=list-recipes-tool.handler.d.ts.map

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs the server over stdio until the transport closes. This is what
+ * `bin/opencraw-mcp.mjs` calls; an MCP host launches it as a subprocess and
+ * talks JSON-RPC over stdin/stdout, so there is no argv to parse.
+ */
+export declare function main(): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

package/dist/probe-tool/index.d.ts

@@ -0,0 +1,2 @@
+export { probeTool, probeInputShape } from './probe-tool.handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/probe-tool/probe-tool.handler.d.ts

@@ -0,0 +1,27 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+/** Input schema for the `probe` tool: a raw zod shape, as `McpServer.registerTool` expects. */
+export declare const probeInputShape: {
+    url: z.ZodString;
+    browser: z.ZodOptional<z.ZodBoolean>;
+    browserPath: z.ZodOptional<z.ZodString>;
+    insecureTls: z.ZodOptional<z.ZodBoolean>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodString>;
+};
+/**
+ * The `probe` tool: fetches a page and reports where its data lives, so an
+ * agent can write an extraction recipe without guessing selectors.
+ *
+ * @param args - The tool's parsed input.
+ * @returns The MCP tool result: the probe findings as JSON text.
+ */
+export declare function probeTool(args: {
+    url: string;
+    browser?: boolean;
+    browserPath?: string;
+    insecureTls?: boolean;
+    userAgent?: string;
+    access?: string;
+}): Promise<CallToolResult>;
+//# sourceMappingURL=probe-tool.handler.d.ts.map

package/dist/recipe-source/index.d.ts

@@ -0,0 +1,3 @@
+export { recipeSourceShape, recipeSourceOf } from './recipe-source.mapper';
+export type { RecipeSourceArgs } from './recipe-source.mapper';
+//# sourceMappingURL=index.d.ts.map

package/dist/recipe-source/recipe-source.mapper.d.ts

@@ -0,0 +1,21 @@
+import type { RecipeSource } from '@opencraw/core';
+import { z } from 'zod';
+/** The two ways a tool takes recipes: files, or the recipes themselves. */
+export declare const recipeSourceShape: {
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recipes: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>>;
+};
+/** A tool's recipe arguments. */
+export interface RecipeSourceArgs {
+    paths?: string[];
+    recipes?: string | Record<string, unknown>[];
+}
+/**
+ * The recipe source a tool call names.
+ *
+ * @param args - The tool's parsed input.
+ * @returns What core reads: the paths, or the inline recipes.
+ * @throws Error when the call gives both or neither.
+ */
+export declare function recipeSourceOf(args: RecipeSourceArgs): RecipeSource;
+//# sourceMappingURL=recipe-source.mapper.d.ts.map

package/dist/run-tool/index.d.ts

@@ -0,0 +1,3 @@
+export { runTool, runInputShape } from './run-tool.handler';
+export type { RunResult } from './run-tool.handler';
+//# sourceMappingURL=index.d.ts.map