@expandai/mcp-server 0.1.1

package/src/generated/ExpandClient.ts

@@ -0,0 +1,821 @@
+/**
+ * @since 1.0.0
+ */
+import type * as HttpClient from '@effect/platform/HttpClient'
+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 Effect from 'effect/Effect'
+import type { ParseError } from 'effect/ParseResult'
+import * as S from 'effect/Schema'
+
+export class AssetsGetByUrlParams extends S.Struct({
+	url: S.String,
+}) {}
+
+/**
+ * The tag identifying the type of parse issue
+ */
+export class IssueTag extends S.Literal(
+	'Pointer',
+	'Unexpected',
+	'Missing',
+	'Composite',
+	'Refinement',
+	'Transformation',
+	'Type',
+	'Forbidden',
+) {}
+
+export class PropertyKeyEnumTag extends S.Literal('symbol') {}
+
+export class PropertyKey extends S.Union(
+	S.String,
+	S.Number,
+	/**
+	 * an object to be decoded into a globally shared symbol
+	 */
+	S.Struct({
+		_tag: PropertyKeyEnumTag,
+		key: S.String,
+	}),
+) {}
+
+/**
+ * Represents an error encountered while parsing a value to match the schema
+ */
+export class Issue extends S.Class<Issue>('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,
+}) {}
+
+export class HttpApiDecodeErrorTag extends S.Literal('HttpApiDecodeError') {}
+
+/**
+ * The request did not match the expected schema
+ */
+export class HttpApiDecodeError extends S.Class<HttpApiDecodeError>('HttpApiDecodeError')({
+	issues: S.Array(Issue),
+	message: S.String,
+	_tag: HttpApiDecodeErrorTag,
+}) {}
+
+export class UnauthorizedAccessTag extends S.Literal('UnauthorizedAccess') {}
+
+export class UnauthorizedAccess extends S.Class<UnauthorizedAccess>('UnauthorizedAccess')({
+	_tag: UnauthorizedAccessTag,
+}) {}
+
+export class AssetNotFoundTag extends S.Literal('AssetNotFound') {}
+
+export class AssetNotFound extends S.Class<AssetNotFound>('AssetNotFound')({
+	browserSessionId: S.optionalWith(S.String, { nullable: true }),
+	filename: S.String,
+	_tag: AssetNotFoundTag,
+}) {}
+
+export class AssetNotInWaczTag extends S.Literal('AssetNotInWacz') {}
+
+export class AssetNotInWacz extends S.Class<AssetNotInWacz>('AssetNotInWacz')({
+	url: S.String,
+	_tag: AssetNotInWaczTag,
+}) {}
+
+export class AssetsGetByUrl404 extends S.Union(AssetNotFound, AssetNotInWacz) {}
+
+export class AssetReadErrorTag extends S.Literal('AssetReadError') {}
+
+export class AssetReadError extends S.Class<AssetReadError>('AssetReadError')({
+	browserSessionId: S.optionalWith(S.String, { nullable: true }),
+	filename: S.String,
+	_tag: AssetReadErrorTag,
+}) {}
+
+export class InvalidWaczFormatTag extends S.Literal('InvalidWaczFormat') {}
+
+export class InvalidWaczFormat extends S.Class<InvalidWaczFormat>('InvalidWaczFormat')({
+	message: S.String,
+	_tag: InvalidWaczFormatTag,
+}) {}
+
+export class AssetRetrievalErrorTag extends S.Literal('AssetRetrievalError') {}
+
+export class AssetRetrievalError extends S.Class<AssetRetrievalError>('AssetRetrievalError')({
+	browserSessionId: S.String,
+	url: S.String,
+	_tag: AssetRetrievalErrorTag,
+}) {}
+
+export class AssetsGetByUrl500 extends S.Union(AssetReadError, InvalidWaczFormat, AssetRetrievalError) {}
+
+export class CurlErrorInputMethod extends S.Literal(
+	'GET',
+	'POST',
+	'HEAD',
+	'PUT',
+	'DELETE',
+	'CONNECT',
+	'OPTIONS',
+	'TRACE',
+	'PATCH',
+) {}
+
+export class CurlErrorTag extends S.Literal('CurlError') {}
+
+export class CurlError extends S.Class<CurlError>('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,
+}) {}
+
+export class AssetListItem extends S.Class<AssetListItem>('AssetListItem')({
+	url: S.String,
+	mime: S.String,
+	status: S.Number,
+}) {}
+
+export class AssetListResponse extends S.Class<AssetListResponse>('AssetListResponse')({
+	browserSessionId: S.String,
+	assets: S.Array(AssetListItem),
+}) {}
+
+export class AssetsList500 extends S.Union(AssetReadError, InvalidWaczFormat) {}
+
+/**
+ * a string to be decoded into a URL
+ */
+export class URL extends S.String {}
+
+/**
+ * Options for customizing HTML content extraction
+ */
+export class SelectHtmlConfig extends S.Record({ key: S.String, value: S.Unknown }) {}
+
+/**
+ * Options for customizing markdown content extraction
+ */
+export class SelectMarkdownConfig extends S.Record({ key: S.String, value: S.Unknown }) {}
+
+/**
+ * Options for customizing screenshot capture behavior
+ */
+export class SelectScreenshotConfig extends S.Class<SelectScreenshotConfig>('SelectScreenshotConfig')({
+	/**
+	 * Whether to capture the full page including content below the fold
+	 */
+	fullPage: S.optionalWith(S.Boolean, { nullable: true }),
+}) {}
+
+/**
+ * a string with no leading or trailing whitespace
+ */
+export class Trimmed extends S.String.pipe(S.pattern(/^\S[\s\S]*\S$|^\S$|^$/)) {}
+
+/**
+ * an integer
+ */
+export class Int extends S.Int {}
+
+/**
+ * Request parameters for fetching and extracting content from a web page
+ */
+export class FetchRequest extends S.Class<FetchRequest>('FetchRequest')({
+	url: URL,
+	/**
+	 * Specifies which content formats to include in the response
+	 */
+	select: S.optionalWith(
+		S.Struct({
+			html: S.optionalWith(
+				S.Union(
+					/**
+					 * Set to true to include HTML
+					 */
+					S.Boolean,
+					SelectHtmlConfig,
+				),
+				{ nullable: true },
+			),
+			/**
+			 * Include markdown-formatted content in the response
+			 */
+			markdown: S.optionalWith(
+				S.Union(
+					/**
+					 * Set to true to include markdown
+					 */
+					S.Boolean,
+					SelectMarkdownConfig,
+				),
+				{ nullable: true },
+			),
+			screenshot: S.optionalWith(
+				S.Union(
+					/**
+					 * Set to true to include a screenshot
+					 */
+					S.Boolean,
+					SelectScreenshotConfig,
+				),
+				{ nullable: true },
+			),
+			summary: S.optionalWith(
+				S.Union(
+					/**
+					 * Set to true to generate an AI summary
+					 */
+					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(5000)), {
+							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.' as const,
+						}),
+					}),
+				),
+				{ 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(Int, { nullable: true, default: () => 5 as const }),
+					/**
+					 * 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 as const,
+					}),
+					/**
+					 * Target snippet size in characters (100-2000)
+					 */
+					targetSnippetSize: S.optionalWith(Int, { nullable: true, default: () => 384 as const }),
+				}),
+				{ nullable: true },
+			),
+			/**
+			 * Include page metadata in the response
+			 */
+			meta: S.optionalWith(S.Boolean, { nullable: true, default: () => true as const }),
+			/**
+			 * 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 as const }),
+				}),
+				{ 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 as const }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+/**
+ * HTTP response information (URL, status code, optionally headers)
+ */
+export class ResponseInfo extends S.Class<ResponseInfo>('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 }),
+}) {}
+
+/**
+ * Favicon or app icon metadata from <link> tags
+ */
+export class IconMeta extends S.Class<IconMeta>('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 }),
+}) {}
+
+/**
+ * Open Graph image with optional dimensions and alt text
+ */
+export class OgImage extends S.Class<OgImage>('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 }),
+}) {}
+
+/**
+ * Open Graph protocol metadata for rich link previews
+ */
+export class OpenGraphMeta extends S.Class<OpenGraphMeta>('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 }),
+}) {}
+
+/**
+ * Twitter Card metadata for social sharing previews
+ */
+export class TwitterCardMeta extends S.Class<TwitterCardMeta>('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 }),
+}) {}
+
+/**
+ * Comprehensive metadata extracted from the page HTML head section
+ */
+export class PageMeta extends S.Class<PageMeta>('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 }),
+}) {}
+
+/**
+ * Contains the extracted content in the formats specified by the select configuration
+ */
+export class FetchData extends S.Class<FetchData>('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' as const }),
+				/**
+				 * 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 },
+	),
+}) {}
+
+/**
+ * Complete response from a fetch operation
+ */
+export class FetchResult extends S.Class<FetchResult>('FetchResult')({
+	data: FetchData,
+}) {}
+
+export class FetchErrorTag extends S.Literal('FetchError') {}
+
+export class FetchError extends S.Class<FetchError>('FetchError')({
+	_tag: FetchErrorTag,
+}) {}
+
+/**
+ * Request parameters for fetching and converting web page content to markdown format
+ */
+export class MarkdownRequest extends S.Class<MarkdownRequest>('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 as const }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+export class InvalidAssetHashTag extends S.Literal('InvalidAssetHash') {}
+
+export class InvalidAssetHash extends S.Class<InvalidAssetHash>('InvalidAssetHash')({
+	message: S.String,
+	_tag: InvalidAssetHashTag,
+}) {}
+
+export class AssetNotFoundInHarTag extends S.Literal('AssetNotFoundInHar') {}
+
+export class AssetNotFoundInHar extends S.Class<AssetNotFoundInHar>('AssetNotFoundInHar')({
+	snapshotDir: S.String,
+	assetUrl: S.String,
+	_tag: AssetNotFoundInHarTag,
+}) {}
+
+export class HarNotFoundTag extends S.Literal('HarNotFound') {}
+
+export class HarNotFound extends S.Class<HarNotFound>('HarNotFound')({
+	snapshotDir: S.String,
+	_tag: HarNotFoundTag,
+}) {}
+
+export class AssetFetchErrorTag extends S.Literal('AssetFetchError') {}
+
+export class AssetFetchError extends S.Class<AssetFetchError>('AssetFetchError')({
+	snapshotDir: S.String,
+	assetUrl: S.String,
+	_tag: AssetFetchErrorTag,
+}) {}
+
+export class LocalAssetsGetAsset500 extends S.Union(
+	InvalidAssetHash,
+	AssetNotFoundInHar,
+	HarNotFound,
+	AssetFetchError,
+) {}
+
+export const make = (
+	httpClient: HttpClient.HttpClient,
+	options: {
+		readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined
+	} = {},
+): Client => {
+	const unexpectedStatus = (response: HttpClientResponse.HttpClientResponse) =>
+		Effect.flatMap(
+			Effect.orElseSucceed(response.json, () => 'Unexpected status code'),
+			(description) =>
+				Effect.fail(
+					new HttpClientError.ResponseError({
+						request: response.request,
+						response,
+						reason: 'StatusCode',
+						description: typeof description === 'string' ? description : JSON.stringify(description),
+					}),
+				),
+		)
+	const withResponse: <A, E>(
+		f: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<A, E>,
+	) => (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<any, any> = options.transformClient
+		? (f) => (request) =>
+				Effect.flatMap(
+					Effect.flatMap(options.transformClient!(httpClient), (client) => client.execute(request)),
+					f,
+				)
+		: (f) => (request) => Effect.flatMap(httpClient.execute(request), f)
+	const decodeSuccess =
+		<A, I, R>(schema: S.Schema<A, I, R>) =>
+		(response: HttpClientResponse.HttpClientResponse) =>
+			HttpClientResponse.schemaBodyJson(schema)(response)
+	const decodeError =
+		<const Tag extends string, A, I, R>(tag: Tag, schema: S.Schema<A, I, R>) =>
+		(response: HttpClientResponse.HttpClientResponse) =>
+			Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)(response), (cause) =>
+				Effect.fail(ClientError(tag, cause, response)),
+			)
+	return {
+		httpClient,
+		assetsGetByUrl: (browserSessionId, options) =>
+			HttpClientRequest.get(`/v1/assets/${browserSessionId}/asset`).pipe(
+				HttpClientRequest.setUrlParams({ url: options?.['url'] as any }),
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('UnauthorizedAccess', UnauthorizedAccess),
+						'404': decodeError('AssetsGetByUrl404', AssetsGetByUrl404),
+						'500': decodeError('AssetsGetByUrl500', AssetsGetByUrl500),
+						'502': decodeError('CurlError', CurlError),
+						'429': () => Effect.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': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		fetch: (options) =>
+			HttpClientRequest.post(`/v1/fetch`).pipe(
+				HttpClientRequest.bodyUnsafeJson(options),
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'2xx': decodeSuccess(FetchResult),
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('UnauthorizedAccess', UnauthorizedAccess),
+						'500': decodeError('FetchError', FetchError),
+						'429': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		markdown: (options) =>
+			HttpClientRequest.post(`/v1/fetch/markdown`).pipe(
+				HttpClientRequest.bodyUnsafeJson(options),
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('UnauthorizedAccess', UnauthorizedAccess),
+						'500': decodeError('FetchError', FetchError),
+						'429': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		localAssetsGetAsset: (assetHash) =>
+			HttpClientRequest.get(`/local-asset/${assetHash}`).pipe(
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'500': decodeError('LocalAssetsGetAsset500', LocalAssetsGetAsset500),
+						'204': () => Effect.void,
+						'429': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+	}
+}
+
+export interface Client {
+	readonly httpClient: HttpClient.HttpClient
+	readonly assetsGetByUrl: (
+		browserSessionId: string,
+		options: typeof AssetsGetByUrlParams.Encoded,
+	) => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
+		| ClientError<'AssetsGetByUrl404', typeof AssetsGetByUrl404.Type>
+		| ClientError<'AssetsGetByUrl500', typeof AssetsGetByUrl500.Type>
+		| ClientError<'CurlError', typeof CurlError.Type>
+	>
+	readonly assetsList: (
+		browserSessionId: string,
+	) => Effect.Effect<
+		typeof AssetListResponse.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
+		| ClientError<'AssetNotFound', typeof AssetNotFound.Type>
+		| ClientError<'AssetsList500', typeof AssetsList500.Type>
+	>
+	/**
+	 * Extract content from a web page as HTML, markdown, and/or screenshots. Handles complex rendering and bot protection.
+	 */
+	readonly fetch: (
+		options: typeof FetchRequest.Encoded,
+	) => Effect.Effect<
+		typeof FetchResult.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
+		| ClientError<'FetchError', typeof FetchError.Type>
+	>
+	/**
+	 * Extract and convert web page content to markdown. Returns clean, structured content for LLMs.
+	 */
+	readonly markdown: (
+		options: typeof MarkdownRequest.Encoded,
+	) => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
+		| ClientError<'FetchError', typeof FetchError.Type>
+	>
+	readonly localAssetsGetAsset: (
+		assetHash: string,
+	) => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'LocalAssetsGetAsset500', typeof LocalAssetsGetAsset500.Type>
+	>
+}
+
+export interface ClientError<Tag extends string, E> {
+	readonly _tag: Tag
+	readonly request: HttpClientRequest.HttpClientRequest
+	readonly response: HttpClientResponse.HttpClientResponse
+	readonly cause: E
+}
+
+class ClientErrorImpl extends Data.Error<{
+	_tag: string
+	cause: any
+	request: HttpClientRequest.HttpClientRequest
+	response: HttpClientResponse.HttpClientResponse
+}> {}
+
+export const ClientError = <Tag extends string, E>(
+	tag: Tag,
+	cause: E,
+	response: HttpClientResponse.HttpClientResponse,
+): ClientError<Tag, E> =>
+	new ClientErrorImpl({
+		_tag: tag,
+		cause,
+		response,
+		request: response.request,
+	}) as any