@expandai/mcp-server 0.1.4 → 0.2.1

package/src/Generated.ts

@@ -71,10 +71,14 @@ export class HttpApiDecodeError extends S.Class<HttpApiDecodeError>('HttpApiDeco
 	_tag: HttpApiDecodeErrorTag,
 }) {}
 
-export class UnauthorizedAccessTag extends S.Literal('UnauthorizedAccess') {}
+export class AuthFailedReason extends S.Literal('InvalidApiKey', 'InvalidToken', 'InvalidSession', 'InvalidTenant') {}
 
-export class UnauthorizedAccess extends S.Class<UnauthorizedAccess>('UnauthorizedAccess')({
-	_tag: UnauthorizedAccessTag,
+export class AuthFailedTag extends S.Literal('AuthFailed') {}
+
+export class AuthFailed extends S.Class<AuthFailed>('AuthFailed')({
+	reason: AuthFailedReason,
+	description: S.optionalWith(S.String, { nullable: true }),
+	_tag: AuthFailedTag,
 }) {}
 
 export class AssetNotFoundTag extends S.Literal('AssetNotFound') {}
@@ -117,7 +121,13 @@ export class AssetRetrievalError extends S.Class<AssetRetrievalError>('AssetRetr
 	_tag: AssetRetrievalErrorTag,
 }) {}
 
-export class AssetsGetByUrl500 extends S.Union(AssetReadError, InvalidWaczFormat, AssetRetrievalError) {}
+export class InternalErrorTag extends S.Literal('InternalError') {}
+
+export class InternalError extends S.Class<InternalError>('InternalError')({
+	_tag: InternalErrorTag,
+}) {}
+
+export class AssetsGetByUrl500 extends S.Union(InternalError, AssetReadError, InvalidWaczFormat, AssetRetrievalError) {}
 
 export class CurlErrorInputMethod extends S.Literal(
 	'GET',
@@ -131,6 +141,11 @@ export class CurlErrorInputMethod extends S.Literal(
 	'PATCH',
 ) {}
 
+/**
+ * a string to be decoded into a URL
+ */
+export class URL extends S.String {}
+
 export class CurlErrorTag extends S.Literal('CurlError') {}
 
 export class CurlError extends S.Class<CurlError>('CurlError')({
@@ -141,11 +156,14 @@ export class CurlError extends S.Class<CurlError>('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 }),
@@ -165,12 +183,20 @@ export class AssetListResponse extends S.Class<AssetListResponse>('AssetListResp
 	assets: S.Array(AssetListItem),
 }) {}
 
-export class AssetsList500 extends S.Union(AssetReadError, InvalidWaczFormat) {}
+export class AssetsList500 extends S.Union(InternalError, AssetReadError, InvalidWaczFormat) {}
 
-/**
- * a string to be decoded into a URL
- */
-export class URL extends S.String {}
+export class AssetsGetWacz500 extends S.Union(InternalError, AssetReadError) {}
+
+export class DatasetNotFoundTag extends S.Literal('DatasetNotFound') {}
+
+export class DatasetNotFound extends S.Class<DatasetNotFound>('DatasetNotFound')({
+	path: S.String,
+	_tag: DatasetNotFoundTag,
+}) {}
+
+export class DatasetsGetDataset500 extends S.Union(InternalError, DatasetNotFound) {}
+
+export class DatasetsGetFinetuneDataset500 extends S.Union(InternalError, DatasetNotFound) {}
 
 /**
  * Options for customizing HTML content extraction
@@ -294,6 +320,32 @@ export class FetchRequest extends S.Class<FetchRequest>('FetchRequest')({
 				}),
 				{ nullable: true },
 			),
+			links: S.optionalWith(
+				S.Union(
+					/**
+					 * Set to true to extract links from the page
+					 */
+					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 as const }),
+						/**
+						 * 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
 			 */
@@ -310,6 +362,14 @@ export class FetchRequest extends S.Class<FetchRequest>('FetchRequest')({
 				}),
 				{ nullable: true },
 			),
+			/**
+			 * Include pruned JSON in the response (opt-in)
+			 */
+			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			/**
+			 * Set to true to include extracted links and sidebar content
+			 */
+			appendix: S.optionalWith(S.Boolean, { nullable: true }),
 		}),
 		{ nullable: true },
 	),
@@ -496,63 +556,80 @@ export class PageMeta extends S.Class<PageMeta>('PageMeta')({
 }) {}
 
 /**
- * Contains the extracted content in the formats specified by the select configuration
+ * A link extracted from the page
  */
-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 }),
+export class FetchLink extends S.Class<FetchLink>('FetchLink')({
 	/**
-	 * The HTML content of the fetched page
+	 * The URL of the link
 	 */
-	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' 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 },
-	),
+	text: S.optionalWith(S.String, { nullable: true }),
 }) {}
 
 /**
  * Complete response from a fetch operation
  */
 export class FetchResult extends S.Class<FetchResult>('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' 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 },
+		),
+		/**
+		 * 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 }),
+	}),
 }) {}
 
 export class FetchErrorTag extends S.Literal('FetchError') {}
@@ -561,27 +638,7 @@ 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 Fetch500 extends S.Union(InternalError, FetchError) {}
 
 export class InvalidAssetHashTag extends S.Literal('InvalidAssetHash') {}
 
@@ -614,12 +671,242 @@ export class AssetFetchError extends S.Class<AssetFetchError>('AssetFetchError')
 }) {}
 
 export class LocalAssetsGetAsset500 extends S.Union(
+	InternalError,
 	InvalidAssetHash,
 	AssetNotFoundInHar,
 	HarNotFound,
 	AssetFetchError,
 ) {}
 
+/**
+ * Request parameters for fetching and extracting content from a web page
+ */
+export class PlaygroundFetchRequest extends S.Class<PlaygroundFetchRequest>('PlaygroundFetchRequest')({
+	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 },
+			),
+			links: S.optionalWith(
+				S.Union(
+					/**
+					 * Set to true to extract links from the page
+					 */
+					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 as const }),
+						/**
+						 * 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 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 },
+			),
+			/**
+			 * Include pruned JSON in the response (opt-in)
+			 */
+			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			/**
+			 * 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 as const }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+export class PlaygroundData extends S.Class<PlaygroundData>('PlaygroundData')({
+	response: ResponseInfo,
+	/**
+	 * HTML with expand-id attributes on elements
+	 */
+	html: S.String,
+	browserSessionId: S.String,
+}) {}
+
+export class PlaygroundResult extends S.Class<PlaygroundResult>('PlaygroundResult')({
+	data: PlaygroundData,
+}) {}
+
+export class PlaygroundFetch500 extends S.Union(InternalError, FetchError) {}
+
+export class PlaygroundGet500 extends S.Union(InternalError, FetchError) {}
+
+export class PlaygroundGetBySession500 extends S.Union(InternalError, FetchError) {}
+
+export class PlaygroundSearchRequest extends S.Class<PlaygroundSearchRequest>('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 }),
+}) {}
+
+export class PlaygroundSearchChunk extends S.Class<PlaygroundSearchChunk>('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),
+}) {}
+
+export class PlaygroundSearch200 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 }),
+}) {}
+
+export class PlaygroundSearch500 extends S.Union(InternalError, FetchError) {}
+
 export const make = (
 	httpClient: HttpClient.HttpClient,
 	options: {
@@ -666,52 +953,84 @@ export const make = (
 				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': () => Effect.void,
+						'503': () => Effect.void,
 						orElse: unexpectedStatus,
 					}),
 				),
 			),
 		assetsList: (browserSessionId) =>
-			HttpClientRequest.get(`/v1/assets/${browserSessionId}`).pipe(
+			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': () => Effect.void,
+						'503': () => Effect.void,
 						orElse: unexpectedStatus,
 					}),
 				),
 			),
-		fetch: (options) =>
-			HttpClientRequest.post(`/v1/fetch`).pipe(
-				HttpClientRequest.bodyUnsafeJson(options),
+		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': () => Effect.void,
+						'503': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		datasetsGetDataset: () =>
+			HttpClientRequest.get(`/datasets/page-analysis`).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('DatasetsGetDataset500', DatasetsGetDataset500),
+						'204': () => Effect.void,
+						'429': () => Effect.void,
+						'503': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		datasetsGetFinetuneDataset: () =>
+			HttpClientRequest.get(`/datasets/finetune`).pipe(
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('AuthFailed', AuthFailed),
+						'500': decodeError('DatasetsGetFinetuneDataset500', DatasetsGetFinetuneDataset500),
+						'204': () => Effect.void,
 						'429': () => Effect.void,
+						'503': () => Effect.void,
 						orElse: unexpectedStatus,
 					}),
 				),
 			),
-		markdown: (options) =>
-			HttpClientRequest.post(`/v1/fetch/markdown`).pipe(
+		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),
+						'401': decodeError('AuthFailed', AuthFailed),
+						'500': decodeError('Fetch500', Fetch500),
 						'429': () => Effect.void,
+						'503': () => Effect.void,
 						orElse: unexpectedStatus,
 					}),
 				),
@@ -721,9 +1040,69 @@ export const make = (
 				withResponse(
 					HttpClientResponse.matchStatus({
 						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('AuthFailed', AuthFailed),
 						'500': decodeError('LocalAssetsGetAsset500', LocalAssetsGetAsset500),
 						'204': () => Effect.void,
 						'429': () => Effect.void,
+						'503': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		playgroundFetch: (options) =>
+			HttpClientRequest.post(`/v1/playground/fetch`).pipe(
+				HttpClientRequest.bodyUnsafeJson(options),
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'2xx': decodeSuccess(PlaygroundResult),
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('AuthFailed', AuthFailed),
+						'500': decodeError('PlaygroundFetch500', PlaygroundFetch500),
+						'429': () => Effect.void,
+						'503': () => Effect.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': () => Effect.void,
+						'503': () => Effect.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': () => Effect.void,
+						'503': () => Effect.void,
+						orElse: unexpectedStatus,
+					}),
+				),
+			),
+		playgroundSearch: (options) =>
+			HttpClientRequest.post(`/v1/playground/search`).pipe(
+				HttpClientRequest.bodyUnsafeJson(options),
+				withResponse(
+					HttpClientResponse.matchStatus({
+						'2xx': decodeSuccess(PlaygroundSearch200),
+						'400': decodeError('HttpApiDecodeError', HttpApiDecodeError),
+						'401': decodeError('AuthFailed', AuthFailed),
+						'500': decodeError('PlaygroundSearch500', PlaygroundSearch500),
+						'429': () => Effect.void,
+						'503': () => Effect.void,
 						orElse: unexpectedStatus,
 					}),
 				),
@@ -741,7 +1120,7 @@ export interface Client {
 		| HttpClientError.HttpClientError
 		| ParseError
 		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
-		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
 		| ClientError<'AssetsGetByUrl404', typeof AssetsGetByUrl404.Type>
 		| ClientError<'AssetsGetByUrl500', typeof AssetsGetByUrl500.Type>
 		| ClientError<'CurlError', typeof CurlError.Type>
@@ -753,10 +1132,37 @@ export interface Client {
 		| HttpClientError.HttpClientError
 		| ParseError
 		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
-		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
 		| ClientError<'AssetNotFound', typeof AssetNotFound.Type>
 		| ClientError<'AssetsList500', typeof AssetsList500.Type>
 	>
+	readonly assetsGetWacz: (
+		browserSessionId: string,
+	) => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'AssetNotFound', typeof AssetNotFound.Type>
+		| ClientError<'AssetsGetWacz500', typeof AssetsGetWacz500.Type>
+	>
+	readonly datasetsGetDataset: () => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'DatasetsGetDataset500', typeof DatasetsGetDataset500.Type>
+	>
+	readonly datasetsGetFinetuneDataset: () => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'DatasetsGetFinetuneDataset500', typeof DatasetsGetFinetuneDataset500.Type>
+	>
 	/**
 	 * Extract content from a web page as HTML, markdown, and/or screenshots. Handles complex rendering and bot protection.
 	 */
@@ -767,30 +1173,70 @@ export interface Client {
 		| HttpClientError.HttpClientError
 		| ParseError
 		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
-		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
-		| ClientError<'FetchError', typeof FetchError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'Fetch500', typeof Fetch500.Type>
+	>
+	readonly localAssetsGetAsset: (
+		assetHash: string,
+	) => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'LocalAssetsGetAsset500', typeof LocalAssetsGetAsset500.Type>
 	>
 	/**
-	 * Extract and convert web page content to markdown. Returns clean, structured content for LLMs.
+	 * Returns HTML with expand-id attributes and mdast tree with originalNodeId references.
 	 */
-	readonly markdown: (
-		options: typeof MarkdownRequest.Encoded,
+	readonly playgroundFetch: (
+		options: typeof PlaygroundFetchRequest.Encoded,
 	) => Effect.Effect<
-		void,
+		typeof PlaygroundResult.Type,
 		| HttpClientError.HttpClientError
 		| ParseError
 		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
-		| ClientError<'UnauthorizedAccess', typeof UnauthorizedAccess.Type>
-		| ClientError<'FetchError', typeof FetchError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'PlaygroundFetch500', typeof PlaygroundFetch500.Type>
 	>
-	readonly localAssetsGetAsset: (
-		assetHash: string,
+	/**
+	 * Returns HTML with expand-id attributes and mdast tree with originalNodeId references.
+	 */
+	readonly playgroundGet: (
+		fetchRequestId: string,
 	) => Effect.Effect<
-		void,
+		typeof PlaygroundResult.Type,
 		| HttpClientError.HttpClientError
 		| ParseError
 		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
-		| ClientError<'LocalAssetsGetAsset500', typeof LocalAssetsGetAsset500.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'PlaygroundGet500', typeof PlaygroundGet500.Type>
+	>
+	/**
+	 * Returns HTML with expand-id attributes and mdast tree with originalNodeId references.
+	 */
+	readonly playgroundGetBySession: (
+		browserSessionId: string,
+	) => Effect.Effect<
+		typeof PlaygroundResult.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'PlaygroundGetBySession500', typeof PlaygroundGetBySession500.Type>
+	>
+	/**
+	 * Search within fetched page content using semantic search. Returns ranked chunks with nodeIds for highlighting.
+	 */
+	readonly playgroundSearch: (
+		options: typeof PlaygroundSearchRequest.Encoded,
+	) => Effect.Effect<
+		typeof PlaygroundSearch200.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| ClientError<'HttpApiDecodeError', typeof HttpApiDecodeError.Type>
+		| ClientError<'AuthFailed', typeof AuthFailed.Type>
+		| ClientError<'PlaygroundSearch500', typeof PlaygroundSearch500.Type>
 	>
 }