@expandai/mcp-server 0.1.3 → 0.2.0

package/dist/{chunk-7ECG3QBA.js → chunk-MEO7UHLG.js}

@@ -1,4 +1,4 @@
-import { Effect, Config, Schema, Layer, Redacted } from 'effect';
+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';
@@ -13,7 +13,7 @@ import * as S from 'effect/Schema';
 
 // package.json
 var package_default = {
-  version: "0.1.3"};
+  version: "0.2.0"};
 var ExpandDocs = McpServer.resource({
   uri: "expand://about",
   name: "About expand.ai",
@@ -77,10 +77,14 @@ var HttpApiDecodeError = class extends S.Class("HttpApiDecodeError")({
   _tag: HttpApiDecodeErrorTag
 }) {
 };
-var UnauthorizedAccessTag = class extends S.Literal("UnauthorizedAccess") {
+var AuthFailedReason = class extends S.Literal("InvalidApiKey", "InvalidToken", "InvalidSession", "InvalidTenant") {
 };
-var UnauthorizedAccess = class extends S.Class("UnauthorizedAccess")({
-  _tag: UnauthorizedAccessTag
+var AuthFailedTag = class extends S.Literal("AuthFailed") {
+};
+var AuthFailed = class extends S.Class("AuthFailed")({
+  reason: AuthFailedReason,
+  description: S.optionalWith(S.String, { nullable: true }),
+  _tag: AuthFailedTag
 }) {
 };
 var AssetNotFoundTag = class extends S.Literal("AssetNotFound") {
@@ -123,7 +127,13 @@ var AssetRetrievalError = class extends S.Class("AssetRetrievalError")({
   _tag: AssetRetrievalErrorTag
 }) {
 };
-var AssetsGetByUrl500 = class extends S.Union(AssetReadError, InvalidWaczFormat, AssetRetrievalError) {
+var InternalErrorTag = class extends S.Literal("InternalError") {
+};
+var InternalError = class extends S.Class("InternalError")({
+  _tag: InternalErrorTag
+}) {
+};
+var AssetsGetByUrl500 = class extends S.Union(InternalError, AssetReadError, InvalidWaczFormat, AssetRetrievalError) {
 };
 var CurlErrorInputMethod = class extends S.Literal(
   "GET",
@@ -137,6 +147,8 @@ var CurlErrorInputMethod = class extends S.Literal(
   "PATCH"
 ) {
 };
+var URL = class extends S.String {
+};
 var CurlErrorTag = class extends S.Literal("CurlError") {
 };
 var CurlError = class extends S.Class("CurlError")({
@@ -147,11 +159,14 @@ var CurlError = class extends S.Class("CurlError")({
     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 })
-      }),
+      S.Union(
+        S.Struct({
+          server: S.String,
+          username: S.optionalWith(S.String, { nullable: true }),
+          password: S.optionalWith(S.String, { nullable: true })
+        }),
+        URL
+      ),
       { nullable: true }
     ),
     timeout: S.optionalWith(S.Number, { nullable: true }),
@@ -171,9 +186,20 @@ var AssetListResponse = class extends S.Class("AssetListResponse")({
   assets: S.Array(AssetListItem)
 }) {
 };
-var AssetsList500 = class extends S.Union(AssetReadError, InvalidWaczFormat) {
+var AssetsList500 = class extends S.Union(InternalError, AssetReadError, InvalidWaczFormat) {
 };
-var URL = class extends S.String {
+var AssetsGetWacz500 = class extends S.Union(InternalError, AssetReadError) {
+};
+var DatasetNotFoundTag = class extends S.Literal("DatasetNotFound") {
+};
+var DatasetNotFound = class extends S.Class("DatasetNotFound")({
+  path: S.String,
+  _tag: DatasetNotFoundTag
+}) {
+};
+var DatasetsGetDataset500 = class extends S.Union(InternalError, DatasetNotFound) {
+};
+var DatasetsGetFinetuneDataset500 = class extends S.Union(InternalError, DatasetNotFound) {
 };
 var SelectHtmlConfig = class extends S.Record({ key: S.String, value: S.Unknown }) {
 };
@@ -266,6 +292,29 @@ var Int2 = class extends S.Int {
         }),
         { nullable: true }
       ),
+      links: S.optionalWith(
+        S.Union(
+          S.Boolean,
+          /**
+           * Options for customizing link extraction from the page
+           */
+          S.Struct({
+            /**
+             * Only include links from the same domain as the fetched URL
+             */
+            sameDomainOnly: S.optionalWith(S.Boolean, { nullable: true, default: () => true }),
+            /**
+             * Regex patterns - only include links matching at least one pattern
+             */
+            includePatterns: S.optionalWith(S.Array(S.String), { nullable: true }),
+            /**
+             * Regex patterns - exclude links matching any pattern
+             */
+            excludePatterns: S.optionalWith(S.Array(S.String), { nullable: true })
+          })
+        ),
+        { nullable: true }
+      ),
       /**
        * Include page metadata in the response
        */
@@ -281,7 +330,15 @@ var Int2 = class extends S.Int {
           includeHeaders: S.optionalWith(S.Boolean, { nullable: true, default: () => false })
         }),
         { nullable: true }
-      )
+      ),
+      /**
+       * Include pruned JSON in the response (opt-in)
+       */
+      json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+      /**
+       * Set to true to include extracted links and sidebar content
+       */
+      appendix: S.optionalWith(S.Boolean, { nullable: true })
     }),
     { nullable: true }
   ),
@@ -449,58 +506,75 @@ var PageMeta = class extends S.Class("PageMeta")({
   twitter: S.optionalWith(TwitterCardMeta, { nullable: true })
 }) {
 };
-var FetchData = class extends S.Class("FetchData")({
-  response: ResponseInfo,
+var FetchLink = class extends S.Class("FetchLink")({
   /**
-   * Page metadata extracted from HTML head (title, description, Open Graph, Twitter Card, icons)
+   * The URL of the link
    */
-  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 }),
+  url: S.String,
   /**
-   * Relevant snippets extracted from the page based on the search query
+   * The anchor text of the link
    */
-  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 }
-  )
+  text: S.optionalWith(S.String, { nullable: true })
 }) {
 };
 var FetchResult = class extends S.Class("FetchResult")({
-  data: FetchData
+  /**
+   * Contains the extracted content in the formats specified by the select configuration
+   */
+  data: S.Struct({
+    response: ResponseInfo,
+    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 }
+    ),
+    /**
+     * Links extracted from the page
+     */
+    links: S.optionalWith(S.Array(FetchLink), { nullable: true }),
+    /**
+     * Extracted links and sidebar content
+     */
+    appendix: S.optionalWith(S.String, { nullable: true })
+  })
 }) {
 };
 var FetchErrorTag = class extends S.Literal("FetchError") {
@@ -509,25 +583,8 @@ 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 Fetch500 = class extends S.Union(InternalError, FetchError) {
+};
 var InvalidAssetHashTag = class extends S.Literal("InvalidAssetHash") {
 };
 var InvalidAssetHash = class extends S.Class("InvalidAssetHash")({
@@ -559,12 +616,223 @@ var AssetFetchError = class extends S.Class("AssetFetchError")({
 }) {
 };
 var LocalAssetsGetAsset500 = class extends S.Union(
+  InternalError,
   InvalidAssetHash,
   AssetNotFoundInHar,
   HarNotFound,
   AssetFetchError
 ) {
 };
+(class extends S.Class("PlaygroundFetchRequest")({
+  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 }
+      ),
+      links: S.optionalWith(
+        S.Union(
+          S.Boolean,
+          /**
+           * Options for customizing link extraction from the page
+           */
+          S.Struct({
+            /**
+             * Only include links from the same domain as the fetched URL
+             */
+            sameDomainOnly: S.optionalWith(S.Boolean, { nullable: true, default: () => true }),
+            /**
+             * Regex patterns - only include links matching at least one pattern
+             */
+            includePatterns: S.optionalWith(S.Array(S.String), { nullable: true }),
+            /**
+             * Regex patterns - exclude links matching any pattern
+             */
+            excludePatterns: S.optionalWith(S.Array(S.String), { nullable: true })
+          })
+        ),
+        { 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 }
+      ),
+      /**
+       * Include pruned JSON in the response (opt-in)
+       */
+      json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+      /**
+       * Set to true to include extracted links and sidebar content
+       */
+      appendix: S.optionalWith(S.Boolean, { 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 PlaygroundData = class extends S.Class("PlaygroundData")({
+  response: ResponseInfo,
+  /**
+   * HTML with expand-id attributes on elements
+   */
+  html: S.String,
+  browserSessionId: S.String
+}) {
+};
+var PlaygroundResult = class extends S.Class("PlaygroundResult")({
+  data: PlaygroundData
+}) {
+};
+var PlaygroundFetch500 = class extends S.Union(InternalError, FetchError) {
+};
+var PlaygroundGet500 = class extends S.Union(InternalError, FetchError) {
+};
+var PlaygroundGetBySession500 = class extends S.Union(InternalError, FetchError) {
+};
+(class extends S.Class("PlaygroundSearchRequest")({
+  /**
+   * Search query to find relevant content chunks
+   */
+  query: Trimmed,
+  /**
+   * Browser session ID from the playground fetch result
+   */
+  browserSessionId: S.String,
+  /**
+   * Maximum number of results to return
+   */
+  maxResults: S.optionalWith(S.Number, { nullable: true }),
+  /**
+   * Minimum relevance score threshold (0-1). A value of 0 disables filtering.
+   */
+  minScore: S.optionalWith(S.Number, { nullable: true })
+}) {
+});
+var PlaygroundSearchChunk = class extends S.Class("PlaygroundSearchChunk")({
+  /**
+   * The chunk text content
+   */
+  text: S.String,
+  /**
+   * Relevance score from 0-1
+   */
+  score: S.Number,
+  /**
+   * Original chunk index
+   */
+  index: S.Number,
+  /**
+   * MDAST originalNodeIds for highlighting in HTML/markdown views
+   */
+  nodeIds: S.Array(S.Number)
+}) {
+};
+var PlaygroundSearch200 = class extends S.Struct({
+  /**
+   * Scored and ranked content chunks
+   */
+  chunks: S.Array(PlaygroundSearchChunk),
+  /**
+   * Duration of the search operation in milliseconds
+   */
+  durationMs: S.optionalWith(S.Number, { nullable: true })
+}) {
+};
+var PlaygroundSearch500 = class extends S.Union(InternalError, FetchError) {
+};
 var make = (httpClient, options = {}) => {
   const unexpectedStatus = (response) => Effect2.flatMap(
     Effect2.orElseSucceed(response.json, () => "Unexpected status code"),
@@ -593,49 +861,79 @@ var make = (httpClient, options = {}) => {
       withResponse(
         HttpClientResponse.matchStatus({
           "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
-          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
+          "401": decodeError("AuthFailed", AuthFailed),
           "404": decodeError("AssetsGetByUrl404", AssetsGetByUrl404),
           "500": decodeError("AssetsGetByUrl500", AssetsGetByUrl500),
           "502": decodeError("CurlError", CurlError),
           "429": () => Effect2.void,
+          "503": () => Effect2.void,
           orElse: unexpectedStatus
         })
       )
     ),
-    assetsList: (browserSessionId) => HttpClientRequest.get(`/v1/assets/${browserSessionId}`).pipe(
+    assetsList: (browserSessionId) => HttpClientRequest.get(`/v1/assets/${browserSessionId}/list`).pipe(
       withResponse(
         HttpClientResponse.matchStatus({
           "2xx": decodeSuccess(AssetListResponse),
           "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
-          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
+          "401": decodeError("AuthFailed", AuthFailed),
           "404": decodeError("AssetNotFound", AssetNotFound),
           "500": decodeError("AssetsList500", AssetsList500),
           "429": () => Effect2.void,
+          "503": () => Effect2.void,
           orElse: unexpectedStatus
         })
       )
     ),
-    fetch: (options2) => HttpClientRequest.post(`/v1/fetch`).pipe(
-      HttpClientRequest.bodyUnsafeJson(options2),
+    assetsGetWacz: (browserSessionId) => HttpClientRequest.get(`/v1/assets/${browserSessionId}`).pipe(
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "404": decodeError("AssetNotFound", AssetNotFound),
+          "500": decodeError("AssetsGetWacz500", AssetsGetWacz500),
+          "429": () => Effect2.void,
+          "503": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    datasetsGetDataset: () => HttpClientRequest.get(`/datasets/page-analysis`).pipe(
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("DatasetsGetDataset500", DatasetsGetDataset500),
+          "204": () => Effect2.void,
+          "429": () => Effect2.void,
+          "503": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    datasetsGetFinetuneDataset: () => HttpClientRequest.get(`/datasets/finetune`).pipe(
       withResponse(
         HttpClientResponse.matchStatus({
-          "2xx": decodeSuccess(FetchResult),
           "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
-          "401": decodeError("UnauthorizedAccess", UnauthorizedAccess),
-          "500": decodeError("FetchError", FetchError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("DatasetsGetFinetuneDataset500", DatasetsGetFinetuneDataset500),
+          "204": () => Effect2.void,
           "429": () => Effect2.void,
+          "503": () => Effect2.void,
           orElse: unexpectedStatus
         })
       )
     ),
-    markdown: (options2) => HttpClientRequest.post(`/v1/fetch/markdown`).pipe(
+    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),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("Fetch500", Fetch500),
           "429": () => Effect2.void,
+          "503": () => Effect2.void,
           orElse: unexpectedStatus
         })
       )
@@ -644,9 +942,65 @@ var make = (httpClient, options = {}) => {
       withResponse(
         HttpClientResponse.matchStatus({
           "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
           "500": decodeError("LocalAssetsGetAsset500", LocalAssetsGetAsset500),
           "204": () => Effect2.void,
           "429": () => Effect2.void,
+          "503": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    playgroundFetch: (options2) => HttpClientRequest.post(`/v1/playground/fetch`).pipe(
+      HttpClientRequest.bodyUnsafeJson(options2),
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "2xx": decodeSuccess(PlaygroundResult),
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("PlaygroundFetch500", PlaygroundFetch500),
+          "429": () => Effect2.void,
+          "503": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    playgroundGet: (fetchRequestId) => HttpClientRequest.get(`/v1/playground/get/${fetchRequestId}`).pipe(
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "2xx": decodeSuccess(PlaygroundResult),
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("PlaygroundGet500", PlaygroundGet500),
+          "429": () => Effect2.void,
+          "503": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    playgroundGetBySession: (browserSessionId) => HttpClientRequest.get(`/v1/playground/session/${browserSessionId}`).pipe(
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "2xx": decodeSuccess(PlaygroundResult),
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("PlaygroundGetBySession500", PlaygroundGetBySession500),
+          "429": () => Effect2.void,
+          "503": () => Effect2.void,
+          orElse: unexpectedStatus
+        })
+      )
+    ),
+    playgroundSearch: (options2) => HttpClientRequest.post(`/v1/playground/search`).pipe(
+      HttpClientRequest.bodyUnsafeJson(options2),
+      withResponse(
+        HttpClientResponse.matchStatus({
+          "2xx": decodeSuccess(PlaygroundSearch200),
+          "400": decodeError("HttpApiDecodeError", HttpApiDecodeError),
+          "401": decodeError("AuthFailed", AuthFailed),
+          "500": decodeError("PlaygroundSearch500", PlaygroundSearch500),
+          "429": () => Effect2.void,
+          "503": () => Effect2.void,
           orElse: unexpectedStatus
         })
       )
@@ -664,7 +1018,7 @@ var ClientError = (tag, cause, response) => new ClientErrorImpl({
 
 // src/ExpandClient.ts
 var ExpandConfig = Config.all({
-  apiKey: Config.redacted("EXPAND_API_KEY"),
+  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", {
@@ -672,93 +1026,106 @@ var ExpandClient = class extends Effect.Service()("ExpandClient", {
   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(HttpClientRequest$1.setHeader("x-expand-api-key", Redacted.value(config.apiKey)))
+          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")({
+var SearchParams = class extends Schema.Class("SearchParams")({
   query: Schema.String.annotations({
-    description: "Query to find relevant content snippets from the page"
+    description: "Query to find relevant content snippets"
   }),
-  maxSnippets: Schema.optional(
-    Schema.Int.pipe(Schema.greaterThanOrEqualTo(1), Schema.lessThanOrEqualTo(50))
-  ).annotations({
-    description: "Maximum number of snippets to return (1-50, default: 5)"
+  minScore: Schema.optionalWith(Schema.Number.pipe(Schema.greaterThanOrEqualTo(0), Schema.lessThanOrEqualTo(1)), {
+    default: () => 0.6
+  }).annotations({
+    description: "Minimum relevance score (0-1)",
+    default: 0.6
   }),
-  targetSnippetSize: Schema.optional(
-    Schema.Int.pipe(Schema.greaterThanOrEqualTo(100), Schema.lessThanOrEqualTo(2e3))
-  ).annotations({
-    description: "Target snippet size in characters (100-2000, default: 384)"
+  maxResults: Schema.optionalWith(Schema.Int.pipe(Schema.greaterThanOrEqualTo(1), Schema.lessThanOrEqualTo(50)), {
+    default: () => 5
+  }).annotations({
+    description: "Maximum snippets to return",
+    default: 5
   })
 }) {
 };
-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"
+  includeMeta: Schema.optionalWith(Schema.Boolean, { default: () => false }).annotations({
+    description: "Include page meta tags (title, description, Open Graph)",
+    default: false
+  }),
+  includeAppendix: Schema.optionalWith(Schema.Boolean, { default: () => false }).annotations({
+    description: "Include extracted links and sidebar content",
+    default: false
+  }),
+  includeJson: Schema.optionalWith(Schema.Boolean, { default: () => false }).annotations({
+    description: "Include JSON extracted from network responses and DOM",
+    default: false
+  }),
+  search: Schema.optional(SearchParams).annotations({
+    description: "Semantic search. When provided, returns snippets instead of markdown."
   })
 }) {
 };
-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
+  description: `Fetch and extract content from any URL.
+
+Returns markdown by default. When \`search\` is provided, returns semantically relevant snippets instead.`,
+  parameters: FetchParams.fields
 }).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 fetch = Effect.fn("Fetch.fetch")(function* ({
+      url,
+      includeMeta,
+      includeAppendix,
+      includeJson,
+      search
+    }) {
+      const hasSearch = search !== void 0;
+      yield* Effect.logDebug(`Fetching: ${url}`).pipe(
+        Effect.annotateLogs({ hasSearch, includeMeta, includeAppendix, includeJson })
+      );
       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
+          markdown: !hasSearch,
+          snippets: hasSearch ? {
+            query: search.query,
+            maxSnippets: search.maxResults,
+            minScore: search.minScore
+          } : void 0,
+          meta: includeMeta,
+          json: includeJson,
+          appendix: includeAppendix
         }
       });
-      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
-      });
+      yield* Effect.logDebug(`Fetched successfully: ${result.data.response.url}`);
+      return result.data;
     }, Effect.orDie);
     return { fetch };
   })
@@ -783,6 +1150,8 @@ 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 { ServerInfo, makeServerLayer };
+export { CurrentRequestHeaders, ServerInfo, makeServerLayer };