@expandai/mcp-server 0.1.1 → 0.1.4

package/dist/chunk-TUBB4OP4.js

@@ -0,0 +1,802 @@
+import { Effect, Config, Schema, Layer, Context, Option, Redacted } from 'effect';
+import { McpServer, Tool, Toolkit } from '@effect/ai';
+import { NodeHttpClient } from '@effect/platform-node';
+import { HttpClient, HttpClientRequest as HttpClientRequest$1 } from '@effect/platform';
+import * as HttpClientError from '@effect/platform/HttpClientError';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as HttpClientResponse from '@effect/platform/HttpClientResponse';
+import * as Data from 'effect/Data';
+import * as Effect2 from 'effect/Effect';
+import * as S from 'effect/Schema';
+
+// src/Server.ts
+
+// package.json
+var package_default = {
+  version: "0.1.4"};
+var ExpandDocs = McpServer.resource({
+  uri: "expand://about",
+  name: "About expand.ai",
+  description: "Key links for the expand.ai platform",
+  content: Effect.succeed(`# expand.ai
+
+- Website: https://expand.ai
+- Quickstart: https://expand.ai/docs
+- Dashboard: https://expand.ai/dashboard
+`)
+});
+(class extends S.Struct({
+  url: S.String
+}) {
+});
+var IssueTag = class extends S.Literal(
+  "Pointer",
+  "Unexpected",
+  "Missing",
+  "Composite",
+  "Refinement",
+  "Transformation",
+  "Type",
+  "Forbidden"
+) {
+};
+var PropertyKeyEnumTag = class extends S.Literal("symbol") {
+};
+var PropertyKey = class extends S.Union(
+  S.String,
+  S.Number,
+  /**
+   * an object to be decoded into a globally shared symbol
+   */
+  S.Struct({
+    _tag: PropertyKeyEnumTag,
+    key: S.String
+  })
+) {
+};
+var Issue = class extends S.Class("Issue")({
+  /**
+   * The tag identifying the type of parse issue
+   */
+  _tag: IssueTag,
+  /**
+   * The path to the property where the issue occurred
+   */
+  path: S.Array(PropertyKey),
+  /**
+   * A descriptive message explaining the issue
+   */
+  message: S.String
+}) {
+};
+var HttpApiDecodeErrorTag = class extends S.Literal("HttpApiDecodeError") {
+};
+var HttpApiDecodeError = class extends S.Class("HttpApiDecodeError")({
+  issues: S.Array(Issue),
+  message: S.String,
+  _tag: HttpApiDecodeErrorTag
+}) {
+};
+var UnauthorizedAccessTag = class extends S.Literal("UnauthorizedAccess") {
+};
+var UnauthorizedAccess = class extends S.Class("UnauthorizedAccess")({
+  _tag: UnauthorizedAccessTag
+}) {
+};
+var AssetNotFoundTag = class extends S.Literal("AssetNotFound") {
+};
+var AssetNotFound = class extends S.Class("AssetNotFound")({
+  browserSessionId: S.optionalWith(S.String, { nullable: true }),
+  filename: S.String,
+  _tag: AssetNotFoundTag
+}) {
+};
+var AssetNotInWaczTag = class extends S.Literal("AssetNotInWacz") {
+};
+var AssetNotInWacz = class extends S.Class("AssetNotInWacz")({
+  url: S.String,
+  _tag: AssetNotInWaczTag
+}) {
+};
+var AssetsGetByUrl404 = class extends S.Union(AssetNotFound, AssetNotInWacz) {
+};
+var AssetReadErrorTag = class extends S.Literal("AssetReadError") {
+};
+var AssetReadError = class extends S.Class("AssetReadError")({
+  browserSessionId: S.optionalWith(S.String, { nullable: true }),
+  filename: S.String,
+  _tag: AssetReadErrorTag
+}) {
+};
+var InvalidWaczFormatTag = class extends S.Literal("InvalidWaczFormat") {
+};
+var InvalidWaczFormat = class extends S.Class("InvalidWaczFormat")({
+  message: S.String,
+  _tag: InvalidWaczFormatTag
+}) {
+};
+var AssetRetrievalErrorTag = class extends S.Literal("AssetRetrievalError") {
+};
+var AssetRetrievalError = class extends S.Class("AssetRetrievalError")({
+  browserSessionId: S.String,
+  url: S.String,
+  _tag: AssetRetrievalErrorTag
+}) {
+};
+var AssetsGetByUrl500 = class extends S.Union(AssetReadError, InvalidWaczFormat, AssetRetrievalError) {
+};
+var CurlErrorInputMethod = class extends S.Literal(
+  "GET",
+  "POST",
+  "HEAD",
+  "PUT",
+  "DELETE",
+  "CONNECT",
+  "OPTIONS",
+  "TRACE",
+  "PATCH"
+) {
+};
+var CurlErrorTag = class extends S.Literal("CurlError") {
+};
+var CurlError = class extends S.Class("CurlError")({
+  status: S.Number,
+  input: S.Struct({
+    method: CurlErrorInputMethod,
+    url: S.String,
+    body: S.optionalWith(S.String, { nullable: true }),
+    headers: S.optionalWith(S.Struct({}), { nullable: true }),
+    proxy: S.optionalWith(
+      S.Struct({
+        server: S.String,
+        username: S.optionalWith(S.String, { nullable: true }),
+        password: S.optionalWith(S.String, { nullable: true })
+      }),
+      { nullable: true }
+    ),
+    timeout: S.optionalWith(S.Number, { nullable: true }),
+    connectTimeout: S.optionalWith(S.Number, { nullable: true })
+  }),
+  _tag: CurlErrorTag
+}) {
+};
+var AssetListItem = class extends S.Class("AssetListItem")({
+  url: S.String,
+  mime: S.String,
+  status: S.Number
+}) {
+};
+var AssetListResponse = class extends S.Class("AssetListResponse")({
+  browserSessionId: S.String,
+  assets: S.Array(AssetListItem)
+}) {
+};
+var AssetsList500 = class extends S.Union(AssetReadError, InvalidWaczFormat) {
+};
+var URL = class extends S.String {
+};
+var SelectHtmlConfig = class extends S.Record({ key: S.String, value: S.Unknown }) {
+};
+var SelectMarkdownConfig = class extends S.Record({ key: S.String, value: S.Unknown }) {
+};
+var SelectScreenshotConfig = class extends S.Class("SelectScreenshotConfig")({
+  /**
+   * Whether to capture the full page including content below the fold
+   */
+  fullPage: S.optionalWith(S.Boolean, { nullable: true })
+}) {
+};
+var Trimmed = class extends S.String.pipe(S.pattern(/^\S[\s\S]*\S$|^\S$|^$/)) {
+};
+var Int2 = class extends S.Int {
+};
+(class extends S.Class("FetchRequest")({
+  url: URL,
+  /**
+   * Specifies which content formats to include in the response
+   */
+  select: S.optionalWith(
+    S.Struct({
+      html: S.optionalWith(
+        S.Union(
+          S.Boolean,
+          SelectHtmlConfig
+        ),
+        { nullable: true }
+      ),
+      /**
+       * Include markdown-formatted content in the response
+       */
+      markdown: S.optionalWith(
+        S.Union(
+          S.Boolean,
+          SelectMarkdownConfig
+        ),
+        { nullable: true }
+      ),
+      screenshot: S.optionalWith(
+        S.Union(
+          S.Boolean,
+          SelectScreenshotConfig
+        ),
+        { nullable: true }
+      ),
+      summary: S.optionalWith(
+        S.Union(
+          S.Boolean,
+          /**
+           * Options for AI-powered page summarization
+           */
+          S.Struct({
+            /**
+             * Custom prompt for AI summarization (max 5000 characters)
+             */
+            prompt: S.optionalWith(S.String.pipe(S.maxLength(5e3)), {
+              nullable: true,
+              default: () => "You are a helpful assistant that summarizes web page content.\nGiven the markdown content of a web page, provide a clear and concise summary.\nFocus on the main points and key information.\nKeep the summary informative but brief."
+            })
+          })
+        ),
+        { nullable: true }
+      ),
+      /**
+       * Options for extracting relevant snippets from page content using semantic search
+       */
+      snippets: S.optionalWith(
+        S.Struct({
+          /**
+           * Query to find relevant content snippets from the page (required, non-empty)
+           */
+          query: Trimmed,
+          /**
+           * Maximum number of snippets to return (1-50)
+           */
+          maxSnippets: S.optionalWith(Int2, { nullable: true, default: () => 5 }),
+          /**
+           * Minimum relevance score threshold (0-1). Snippets below this score are filtered out.
+           */
+          minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
+            nullable: true,
+            default: () => 0.5
+          }),
+          /**
+           * Target snippet size in characters (100-2000)
+           */
+          targetSnippetSize: S.optionalWith(Int2, { nullable: true, default: () => 384 })
+        }),
+        { nullable: true }
+      ),
+      /**
+       * Include page metadata in the response
+       */
+      meta: S.optionalWith(S.Boolean, { nullable: true, default: () => true }),
+      /**
+       * Configure response info options (headers inclusion)
+       */
+      response: S.optionalWith(
+        S.Struct({
+          /**
+           * Whether to include HTTP response headers
+           */
+          includeHeaders: S.optionalWith(S.Boolean, { nullable: true, default: () => false })
+        }),
+        { nullable: true }
+      )
+    }),
+    { nullable: true }
+  ),
+  /**
+   * Configuration options for browser behavior during the fetch
+   */
+  browserConfig: S.optionalWith(
+    S.Struct({
+      /**
+       * Whether to scroll the entire page to capture lazy-loaded content
+       */
+      scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false })
+    }),
+    { nullable: true }
+  )
+}) {
+});
+var ResponseInfo = class extends S.Class("ResponseInfo")({
+  /**
+   * The URL that was fetched
+   */
+  url: S.String,
+  /**
+   * HTTP status code of the response
+   */
+  statusCode: S.Number,
+  /**
+   * Response headers from the fetch operation (keys are lower-cased HTTP header names)
+   */
+  headers: S.optionalWith(S.Struct({}), { nullable: true })
+}) {
+};
+var IconMeta = class extends S.Class("IconMeta")({
+  /**
+   * Icon URL or path
+   */
+  href: S.String,
+  /**
+   * Link relationship type
+   */
+  rel: S.String,
+  /**
+   * MIME type of the icon
+   */
+  type: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Icon dimensions
+   */
+  sizes: S.optionalWith(S.String, { nullable: true })
+}) {
+};
+var OgImage = class extends S.Class("OgImage")({
+  /**
+   * Image URL
+   */
+  url: S.String,
+  /**
+   * Image width in pixels
+   */
+  width: S.optionalWith(S.Number, { nullable: true }),
+  /**
+   * Image height in pixels
+   */
+  height: S.optionalWith(S.Number, { nullable: true }),
+  /**
+   * Image alt text for accessibility
+   */
+  alt: S.optionalWith(S.String, { nullable: true })
+}) {
+};
+var OpenGraphMeta = class extends S.Class("OpenGraphMeta")({
+  /**
+   * Open Graph title (og:title)
+   */
+  title: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Open Graph description (og:description)
+   */
+  description: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Open Graph type (og:type) - website, article, product, etc.
+   */
+  type: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Canonical URL for the content (og:url)
+   */
+  url: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Site name (og:site_name)
+   */
+  siteName: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Locale in language_TERRITORY format (og:locale)
+   */
+  locale: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Open Graph images (og:image and related properties)
+   */
+  images: S.optionalWith(S.Array(OgImage), { nullable: true })
+}) {
+};
+var TwitterCardMeta = class extends S.Class("TwitterCardMeta")({
+  /**
+   * Twitter card type (twitter:card)
+   */
+  card: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Twitter @username of the website (twitter:site)
+   */
+  site: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Twitter @username of content creator (twitter:creator)
+   */
+  creator: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Title for Twitter card (twitter:title)
+   */
+  title: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Description for Twitter card (twitter:description)
+   */
+  description: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Image URL for Twitter card (twitter:image)
+   */
+  image: S.optionalWith(S.String, { nullable: true })
+}) {
+};
+var PageMeta = class extends S.Class("PageMeta")({
+  /**
+   * Page title from <title> tag
+   */
+  title: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Meta description from <meta name="description">
+   */
+  description: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Canonical URL from <link rel="canonical">
+   */
+  canonicalUrl: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Page language from <html lang="...">
+   */
+  language: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Character encoding from <meta charset="...">
+   */
+  charset: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Primary favicon URL (first icon found)
+   */
+  favicon: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * All icon links (favicons, apple-touch-icons, etc.)
+   */
+  icons: S.optionalWith(S.Array(IconMeta), { nullable: true }),
+  /**
+   * Open Graph metadata from og:* meta tags
+   */
+  openGraph: S.optionalWith(OpenGraphMeta, { nullable: true }),
+  /**
+   * Twitter Card metadata from twitter:* meta tags
+   */
+  twitter: S.optionalWith(TwitterCardMeta, { nullable: true })
+}) {
+};
+var FetchData = class extends S.Class("FetchData")({
+  response: ResponseInfo,
+  /**
+   * Page metadata extracted from HTML head (title, description, Open Graph, Twitter Card, icons)
+   */
+  meta: S.optionalWith(PageMeta, { nullable: true }),
+  /**
+   * The HTML content of the fetched page
+   */
+  html: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * The markdown-formatted content extracted from the page
+   */
+  markdown: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Base64-encoded data URI of the screenshot image
+   */
+  screenshot: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * AI-generated summary of the page content
+   */
+  summary: S.optionalWith(S.String, { nullable: true }),
+  /**
+   * Relevant snippets extracted from the page based on the search query
+   */
+  snippets: S.optionalWith(
+    S.Array(
+      S.Struct({
+        /**
+         * Type identifier for TextPart compatibility
+         */
+        type: S.optionalWith(S.Literal("text"), { nullable: true, default: () => "text" }),
+        /**
+         * The text content of the snippet
+         */
+        text: S.String,
+        /**
+         * Relevance score from the reranker (0-1)
+         */
+        score: S.Number,
+        /**
+         * Original chunk index
+         */
+        index: S.Number
+      })
+    ),
+    { nullable: true }
+  )
+}) {
+};
+var FetchResult = class extends S.Class("FetchResult")({
+  data: FetchData
+}) {
+};
+var FetchErrorTag = class extends S.Literal("FetchError") {
+};
+var FetchError = class extends S.Class("FetchError")({
+  _tag: FetchErrorTag
+}) {
+};
+(class extends S.Class("MarkdownRequest")({
+  /**
+   * The URL to fetch markdown content from
+   */
+  url: S.String,
+  /**
+   * Configuration options for browser behavior during the fetch
+   */
+  browserConfig: S.optionalWith(
+    S.Struct({
+      /**
+       * Whether to scroll the entire page to capture lazy-loaded content
+       */
+      scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false })
+    }),
+    { nullable: true }
+  )
+}) {
+});
+var InvalidAssetHashTag = class extends S.Literal("InvalidAssetHash") {
+};
+var InvalidAssetHash = class extends S.Class("InvalidAssetHash")({
+  message: S.String,
+  _tag: InvalidAssetHashTag
+}) {
+};
+var AssetNotFoundInHarTag = class extends S.Literal("AssetNotFoundInHar") {
+};
+var AssetNotFoundInHar = class extends S.Class("AssetNotFoundInHar")({
+  snapshotDir: S.String,
+  assetUrl: S.String,
+  _tag: AssetNotFoundInHarTag
+}) {
+};
+var HarNotFoundTag = class extends S.Literal("HarNotFound") {
+};
+var HarNotFound = class extends S.Class("HarNotFound")({
+  snapshotDir: S.String,
+  _tag: HarNotFoundTag
+}) {
+};
+var AssetFetchErrorTag = class extends S.Literal("AssetFetchError") {
+};
+var AssetFetchError = class extends S.Class("AssetFetchError")({
+  snapshotDir: S.String,
+  assetUrl: S.String,
+  _tag: AssetFetchErrorTag
+}) {
+};
+var LocalAssetsGetAsset500 = class extends S.Union(
+  InvalidAssetHash,
+  AssetNotFoundInHar,
+  HarNotFound,
+  AssetFetchError
+) {
+};
+var make = (httpClient, options = {}) => {
+  const unexpectedStatus = (response) => Effect2.flatMap(
+    Effect2.orElseSucceed(response.json, () => "Unexpected status code"),
+    (description) => Effect2.fail(
+      new HttpClientError.ResponseError({
+        request: response.request,
+        response,
+        reason: "StatusCode",
+        description: typeof description === "string" ? description : JSON.stringify(description)
+      })
+    )
+  );
+  const withResponse = options.transformClient ? (f) => (request) => Effect2.flatMap(
+    Effect2.flatMap(options.transformClient(httpClient), (client) => client.execute(request)),
+    f
+  ) : (f) => (request) => Effect2.flatMap(httpClient.execute(request), f);
+  const decodeSuccess = (schema) => (response) => HttpClientResponse.schemaBodyJson(schema)(response);
+  const decodeError = (tag, schema) => (response) => Effect2.flatMap(
+    HttpClientResponse.schemaBodyJson(schema)(response),
+    (cause) => Effect2.fail(ClientError(tag, cause, response))
+  );
+  return {
+    httpClient,
+    assetsGetByUrl: (browserSessionId, options2) => HttpClientRequest.get(`/v1/assets/${browserSessionId}/asset`).pipe(
+      HttpClientRequest.setUrlParams({ url: options2?.["url"] }),
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
+          "404": decodeError("AssetsGetByUrl404", AssetsGetByUrl404),
+          "500": decodeError("AssetsGetByUrl500", AssetsGetByUrl500),
+          "502": decodeError("CurlError", CurlError),
+          "429": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    assetsList: (browserSessionId) => HttpClientRequest.get(`/v1/assets/${browserSessionId}`).pipe(
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "2xx": decodeSuccess(AssetListResponse),
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
+          "404": decodeError("AssetNotFound", AssetNotFound),
+          "500": decodeError("AssetsList500", AssetsList500),
+          "429": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    fetch: (options2) => HttpClientRequest.post(`/v1/fetch`).pipe(
+      HttpClientRequest.bodyUnsafeJson(options2),
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "2xx": decodeSuccess(FetchResult),
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
+          "500": decodeError("FetchError", FetchError),
+          "429": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    markdown: (options2) => HttpClientRequest.post(`/v1/fetch/markdown`).pipe(
+      HttpClientRequest.bodyUnsafeJson(options2),
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
+          "500": decodeError("FetchError", FetchError),
+          "429": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    localAssetsGetAsset: (assetHash) => HttpClientRequest.get(`/local-asset/${assetHash}`).pipe(
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "500": decodeError("LocalAssetsGetAsset500", LocalAssetsGetAsset500),
+          "204": () => Effect2.void,
+          "429": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    )
+  };
+};
+var ClientErrorImpl = class extends Data.Error {
+};
+var ClientError = (tag, cause, response) => new ClientErrorImpl({
+  _tag: tag,
+  cause,
+  response,
+  request: response.request
+});
+
+// src/ExpandClient.ts
+var ExpandConfig = Config.all({
+  apiKey: Config.option(Config.redacted("EXPAND_API_KEY")),
+  baseUrl: Config.withDefault(Config.string("EXPAND_BASE_URL"), "https://api.expand.ai")
+});
+var ExpandClient = class extends Effect.Service()("ExpandClient", {
+  dependencies: [],
+  scoped: Effect.gen(function* () {
+    const config = yield* ExpandConfig;
+    const httpClient = yield* HttpClient.HttpClient;
+    const requestHeaders = yield* Effect.serviceOption(CurrentRequestHeaders);
+    yield* Effect.logInfo(`ExpandClient connected to ${config.baseUrl}`);
+    return make(httpClient, {
+      transformClient: (client) => Effect.succeed(
+        client.pipe(
+          HttpClient.mapRequest(HttpClientRequest$1.prependUrl(config.baseUrl)),
+          HttpClient.mapRequest((req) => {
+            if (Option.isSome(requestHeaders)) {
+              const auth = requestHeaders.value["authorization"];
+              if (auth) {
+                return HttpClientRequest$1.setHeader("authorization", auth)(req);
+              }
+            }
+            if (Option.isSome(config.apiKey)) {
+              return HttpClientRequest$1.setHeader("x-expand-api-key", Redacted.value(config.apiKey.value))(req);
+            }
+            return req;
+          })
+        )
+      )
+    });
+  })
+}) {
+};
+var SnippetsFormat = class extends Schema.Class("SnippetsFormat")({
+  query: Schema.String.annotations({
+    description: "Query to find relevant content snippets from the page"
+  }),
+  maxSnippets: Schema.optional(
+    Schema.Int.pipe(Schema.greaterThanOrEqualTo(1), Schema.lessThanOrEqualTo(50))
+  ).annotations({
+    description: "Maximum number of snippets to return (1-50, default: 5)"
+  }),
+  targetSnippetSize: Schema.optional(
+    Schema.Int.pipe(Schema.greaterThanOrEqualTo(100), Schema.lessThanOrEqualTo(2e3))
+  ).annotations({
+    description: "Target snippet size in characters (100-2000, default: 384)"
+  })
+}) {
+};
+var Format = Schema.Union(
+  Schema.Literal("markdown").annotations({
+    description: "Return as cleaned markdown content"
+  }),
+  Schema.Literal("html").annotations({
+    description: "Return as raw HTML content"
+  }),
+  Schema.Literal("summary").annotations({
+    description: "Return AI-generated summary of the page content"
+  }),
+  SnippetsFormat
+).annotations({
+  description: "Output format for the fetched content"
+});
+var FetchParams = class extends Schema.Class("FetchParams")({
+  url: Schema.String.annotations({
+    description: "The URL to fetch content from"
+  }),
+  format: Format,
+  includeMeta: Schema.Boolean.annotations({
+    description: "Whether to include page meta tags in the response"
+  })
+}) {
+};
+var FetchResult2 = class extends Schema.Class("FetchResult")({
+  content: Schema.String,
+  url: Schema.String,
+  meta: Schema.optional(PageMeta)
+}) {
+};
+var FetchTool = Tool.make("fetch", {
+  description: "Fetch and extract content from any URL.",
+  parameters: FetchParams.fields,
+  success: FetchResult2
+}).annotate(Tool.Readonly, true).annotate(Tool.Destructive, false);
+var Fetch = class extends Effect.Service()("Fetch", {
+  dependencies: [ExpandClient.Default],
+  scoped: Effect.gen(function* () {
+    const client = yield* ExpandClient;
+    const fetch = Effect.fn("Fetch.fetch")(function* ({ url, format, includeMeta }) {
+      const formatLabel = format instanceof SnippetsFormat ? "snippets" : format;
+      yield* Effect.logDebug(`Fetching: ${url}`).pipe(Effect.annotateLogs({ format: formatLabel, includeMeta }));
+      const result = yield* client.fetch({
+        url,
+        select: {
+          markdown: format === "markdown",
+          html: format === "html",
+          summary: format === "summary",
+          snippets: format instanceof SnippetsFormat ? { ...format } : void 0,
+          meta: includeMeta
+        }
+      });
+      const content = result.data.markdown ?? result.data.html ?? result.data.summary ?? result.data.snippets?.map((snippet) => `${snippet.text} (Score: ${snippet.score})`).join("\n") ?? "";
+      yield* Effect.logDebug(`\u{1F4E4} Fetched successfully: ${result.data.response.url}`);
+      return new FetchResult2({
+        content,
+        url: result.data.response.url,
+        meta: result.data.meta
+      });
+    }, Effect.orDie);
+    return { fetch };
+  })
+}) {
+};
+
+// src/Toolkit.ts
+var toolkit = Toolkit.make(FetchTool);
+var ToolkitLayer = toolkit.toLayer(
+  Effect.gen(function* () {
+    yield* Effect.logInfo("Registering tools: fetch");
+    const fetchService = yield* Fetch;
+    return toolkit.of({
+      fetch: fetchService.fetch
+    });
+  })
+).pipe(Layer.provide(Fetch.Default), Layer.provide(ExpandClient.Default), Layer.provide(NodeHttpClient.layerUndici));
+var ExpandToolKit = McpServer.toolkit(toolkit).pipe(Layer.provide(ToolkitLayer));
+
+// src/Server.ts
+var ServerInfo = {
+  name: "expandai-mcp-server",
+  version: package_default.version
+};
+var CurrentRequestHeaders = class extends Context.Tag("CurrentRequestHeaders")() {
+};
+var makeServerLayer = (options = {}) => options.includeDocs ? Layer.mergeAll(ExpandToolKit, ExpandDocs) : ExpandToolKit;
+
+export { CurrentRequestHeaders, ServerInfo, makeServerLayer };