@expandai/mcp-server 0.1.1

package/dist/main.cjs

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