@ouraihub/aether-worker 0.1.0 → 0.1.1

package/src/images/index.ts

@@ -1,15 +1,22 @@
 import type { ImagePart, ImageRef } from '@ouraihub/aether-contracts'
-import { generateImage, ImageFailure, type ImageConnection, type ImageRequest } from '@ouraihub/aether-core/images'
+import {
+  generateImage,
+  ImageFailure,
+  type ImageConnection,
+  type ImageRequest,
+  type ImageGeneration,
+  type ImageLimits,
+} from '@ouraihub/aether-core/images'
 import type { OutboundHttp } from '@ouraihub/aether-core/ports'
 import type { WorkerContext } from '../context.js'
 
-export interface GeneratedImage {
-  readonly image: ImagePart
+export interface GeneratedImage extends ImageGeneration {
   readonly reference: ImageRef
   readonly persisted: boolean
 }
 export interface ImageServiceOptions {
   readonly outbound: OutboundHttp
+  readonly limits?: ImageLimits
   /** Host stores kind=generated under context.actor and returns a controlled display URL. */
   readonly persist?: (image: ImagePart, context: WorkerContext) => Promise<ImageRef>
 }
@@ -21,26 +28,46 @@ export class ImageService {
     this.options = options
   }
 
-  async generate(connection: ImageConnection, input: ImageRequest, context: WorkerContext): Promise<GeneratedImage> {
-    const image = await generateImage(this.options.outbound, connection, input, context.signal)
+  async generate(
+    connection: ImageConnection,
+    input: ImageRequest,
+    context: WorkerContext,
+  ): Promise<GeneratedImage> {
+    const result = await generateImage(
+      this.options.outbound,
+      connection,
+      input,
+      context.signal,
+      this.options.limits,
+    )
+    const { image } = result
     if (!this.options.persist) {
       return {
-        image,
+        ...result,
         reference: { mime: image.mime, url: `data:${image.mime};base64,${image.data}` },
         persisted: false,
       }
     }
     try {
       if (context.signal.aborted)
-        throw new ImageFailure('cancelled', 'Image generated; persistence was cancelled', 'generated')
+        throw new ImageFailure(
+          'cancelled',
+          'Image generated; persistence was cancelled',
+          'generated',
+        )
       const reference = await this.options.persist(image, context)
-      return { image, reference, persisted: true }
+      return { ...result, reference, persisted: true }
     } catch {
       // Generation succeeded. Do not claim the provider did nothing or that saving succeeded.
-      throw new ImageFailure('internal', 'Image generated but persistence could not be confirmed', 'generated', {
-        field: 'images',
-        reason: 'generated_save_failed',
-      })
+      throw new ImageFailure(
+        'internal',
+        'Image generated but persistence could not be confirmed',
+        'generated',
+        {
+          field: 'images',
+          reason: 'generated_save_failed',
+        },
+      )
     }
   }
 }

package/src/logger.ts

@@ -58,18 +58,29 @@ export function createLogger(options: {
 }): Logger {
   const routes = new Set(options.routes)
   for (const route of routes)
-    if (!/^\/[A-Za-z0-9_/:.{}-]*$/u.test(route) || route.length > 256) throw new Error('Invalid log route template')
+    if (!/^\/[A-Za-z0-9_/:.{}-]*$/u.test(route) || route.length > 256)
+      throw new Error('Invalid log route template')
   return Object.freeze({
     log(event: LogEvent, fields: Readonly<Record<string, unknown>>): void {
       if (!Object.hasOwn(EVENTS, event)) throw new Error('Invalid log event')
       const safe: Record<string, LogValue> = {}
       for (const [key, value] of Object.entries(fields)) {
-        if (Object.hasOwn(IDENTIFIERS, key) && typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,128}$/u.test(value))
+        if (
+          Object.hasOwn(IDENTIFIERS, key) &&
+          typeof value === 'string' &&
+          /^[A-Za-z0-9_.:-]{1,128}$/u.test(value)
+        )
           safe[key] = value
-        else if (Object.hasOwn(COUNTERS, key) && typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+        else if (
+          Object.hasOwn(COUNTERS, key) &&
+          typeof value === 'number' &&
+          Number.isSafeInteger(value) &&
+          value >= 0
+        )
           safe[key] = value
         else if (key === 'usageAvailable' && typeof value === 'boolean') safe[key] = value
-        else if (key === 'route' && typeof value === 'string' && routes.has(value)) safe[key] = value
+        else if (key === 'route' && typeof value === 'string' && routes.has(value))
+          safe[key] = value
         else if (
           key === 'state' &&
           (value === 'accepted' ||

package/src/mcp/auth.ts

@@ -2,7 +2,18 @@ import { KitFailure, badRequest } from '@ouraihub/aether-core/error'
 import type { Actor } from '../context.js'
 import type { StoredDocument } from '../storage.js'
 import type { ApiKeyRecord, GrantRecord, McpServiceOptions, McpSettings } from './types.js'
-import { equal, forbidden, hash, notFound, object, random, strings, text, unique, validActor } from './common.js'
+import {
+  equal,
+  forbidden,
+  hash,
+  notFound,
+  object,
+  random,
+  strings,
+  text,
+  unique,
+  validActor,
+} from './common.js'
 
 interface KeyState {
   record: ApiKeyRecord
@@ -106,11 +117,14 @@ export class McpAuth {
       forbidden()
   }
   requested(value: unknown, actor?: Actor): string[] {
-    if (!strings(value) || value.length === 0 || value.length > 100) throw badRequest('scopes', 'invalid')
+    if (!strings(value) || value.length === 0 || value.length > 100)
+      throw badRequest('scopes', 'invalid')
     const scopes = unique(value)
     if (
       scopes.some(
-        (scope) => !this.options.scopes.some((known) => known.id === scope) || (actor && !actor.scopes.includes(scope)),
+        (scope) =>
+          !this.options.scopes.some((known) => known.id === scope) ||
+          (actor && !actor.scopes.includes(scope)),
       )
     )
       forbidden()
@@ -119,17 +133,30 @@ export class McpAuth {
   async settings(owner: Actor): Promise<McpSettings> {
     const doc = await this.options.store.get(owner, 'mcp-settings', 'settings')
     if (!doc) return { enabled: false, enabledScopes: [] }
-    if (!object(doc.value) || typeof doc.value.enabled !== 'boolean' || !strings(doc.value.enabledScopes))
+    if (
+      !object(doc.value) ||
+      typeof doc.value.enabled !== 'boolean' ||
+      !strings(doc.value.enabledScopes)
+    )
       throw new KitFailure('internal', 'Invalid MCP settings')
     return { enabled: doc.value.enabled, enabledScopes: doc.value.enabledScopes }
   }
   async saveSettings(actor: Actor, value: Record<string, unknown>): Promise<McpSettings> {
     this.actor(actor)
-    if (typeof value.enabled !== 'boolean' || !strings(value.enabledScopes)) throw badRequest('settings', 'invalid')
-    const enabledScopes = value.enabledScopes.length ? this.requested(value.enabledScopes, actor) : []
+    if (typeof value.enabled !== 'boolean' || !strings(value.enabledScopes))
+      throw badRequest('settings', 'invalid')
+    const enabledScopes = value.enabledScopes.length
+      ? this.requested(value.enabledScopes, actor)
+      : []
     const current = await this.options.store.get(actor, 'mcp-settings', 'settings')
     const settings = { enabled: value.enabled, enabledScopes }
-    await this.options.store.compareAndSet(actor, 'mcp-settings', 'settings', current?.revision ?? null, settings)
+    await this.options.store.compareAndSet(
+      actor,
+      'mcp-settings',
+      'settings',
+      current?.revision ?? null,
+      settings,
+    )
     return settings
   }
   async keys(actor: Actor): Promise<ApiKeyRecord[]> {
@@ -144,7 +171,8 @@ export class McpAuth {
       result.push(...page.map((doc) => readKey(doc).record))
       if (page.length < 200) return result
       const next = page[page.length - 1]?.key
-      if (!next || (after !== undefined && next <= after)) throw new KitFailure('internal', 'Invalid key pagination')
+      if (!next || (after !== undefined && next <= after))
+        throw new KitFailure('internal', 'Invalid key pagination')
       after = next
     }
   }
@@ -160,7 +188,8 @@ export class McpAuth {
       result.push(...page.map((doc) => readGrant(doc).record))
       if (page.length < 200) return result
       const next = page[page.length - 1]?.key
-      if (!next || (after !== undefined && next <= after)) throw new KitFailure('internal', 'Invalid grant pagination')
+      if (!next || (after !== undefined && next <= after))
+        throw new KitFailure('internal', 'Invalid grant pagination')
       after = next
     }
   }
@@ -175,7 +204,10 @@ export class McpAuth {
     if (!(await this.options.authorizeConsent(actor, scopes, request))) forbidden()
     const now = this.now()
     const expiresAt = input.expiresAt === undefined ? now + 90 * 86400000 : input.expiresAt
-    if (expiresAt !== null && (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || expiresAt <= now))
+    if (
+      expiresAt !== null &&
+      (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || expiresAt <= now)
+    )
       throw badRequest('expiresAt', 'invalid')
     const id = crypto.randomUUID()
     const token = `aether_key_${random()}`
@@ -249,7 +281,9 @@ export class McpAuth {
     const settings = await this.settings(owner)
     if (!settings.enabled) return null
     const effective = scopes.filter(
-      (scope) => settings.enabledScopes.includes(scope) && this.options.scopes.some((known) => known.id === scope),
+      (scope) =>
+        settings.enabledScopes.includes(scope) &&
+        this.options.scopes.some((known) => known.id === scope),
     )
     return {
       actor: { ...owner, kind: 'mcp_client', sessionId: null, scopes: effective },
@@ -302,7 +336,10 @@ export class McpAuth {
     const document = await this.options.store.get(owner, 'mcp-grants', grantId)
     if (!document) throw new KitFailure('unauthorized', 'Invalid grant')
     const state = readGrant(document)
-    if (!this.activeGrant(state, owner) || (clientId !== undefined && state.record.clientId !== clientId))
+    if (
+      !this.activeGrant(state, owner) ||
+      (clientId !== undefined && state.record.clientId !== clientId)
+    )
       throw new KitFailure('unauthorized', 'Invalid grant')
     if (
       refresh !== undefined &&
@@ -319,13 +356,24 @@ export class McpAuth {
       generation: state.generation + 1,
     }
     await this.options.store.compareAndSet(owner, 'mcp-grants', grantId, document.revision, updated)
-    await this.index(await hash(accessToken), { owner, id: grantId, kind: 'access', expiresAt: now + 3600000 })
-    await this.options.store.compareAndSet(this.system, 'mcp-refresh-index', await hash(refreshToken), null, {
+    await this.index(await hash(accessToken), {
       owner,
-      grantId,
-      clientId: state.record.clientId,
-      audience: `${this.options.origin}/mcp`,
+      id: grantId,
+      kind: 'access',
+      expiresAt: now + 3600000,
     })
+    await this.options.store.compareAndSet(
+      this.system,
+      'mcp-refresh-index',
+      await hash(refreshToken),
+      null,
+      {
+        owner,
+        grantId,
+        clientId: state.record.clientId,
+        audience: `${this.options.origin}/mcp`,
+      },
+    )
     return {
       access_token: accessToken,
       token_type: 'Bearer',

package/src/mcp/client.ts

@@ -10,7 +10,12 @@ import {
 } from '@ouraihub/aether-core/mcp'
 import type { OutboundHttp } from '@ouraihub/aether-core/ports'
 import { ownerKey, type Actor, type WorkerContext } from '../context.js'
-import { isSealedCredential, type CredentialPort, type CredentialScope, type SealedCredential } from '../credentials.js'
+import {
+  isSealedCredential,
+  type CredentialPort,
+  type CredentialScope,
+  type SealedCredential,
+} from '../credentials.js'
 import type { DocumentStore } from '../storage.js'
 
 const COLLECTION = 'mcp-client'
@@ -70,7 +75,8 @@ function bool(value: unknown, field: string, fallback?: boolean): boolean {
   return value
 }
 function approval(value: unknown): Approval {
-  if (value !== 'auto' && value !== 'ask' && value !== 'deny') throw badRequest('approval', 'invalid')
+  if (value !== 'auto' && value !== 'ask' && value !== 'deny')
+    throw badRequest('approval', 'invalid')
   return value
 }
 function looksSecret(value: string): boolean {
@@ -95,7 +101,8 @@ function serverUrl(raw: unknown, allowPrivate: boolean): string {
       throw badRequest('url', 'credential_query')
   }
   const host = url.hostname.replace(/^\[|\]$/g, '')
-  const loopback = host === 'localhost' || host.endsWith('.localhost') || host === '::1' || /^127\./.test(host)
+  const loopback =
+    host === 'localhost' || host.endsWith('.localhost') || host === '::1' || /^127\./.test(host)
   if (url.protocol === 'http:' && !allowPrivate) throw badRequest('url', 'plain_http')
   // DNS and connection-time restrictions remain the injected outbound port's responsibility.
   const restricted =
@@ -112,7 +119,8 @@ function maskedUrl(raw: string): string {
   url.username = ''
   url.password = ''
   for (const [name, value] of url.searchParams)
-    if (Object.hasOwn(SECRET_PARAMS, name.toLowerCase()) || looksSecret(value)) url.searchParams.set(name, '***')
+    if (Object.hasOwn(SECRET_PARAMS, name.toLowerCase()) || looksSecret(value))
+      url.searchParams.set(name, '***')
   return url.href
 }
 function strings(value: unknown, field: string): Record<string, string> {
@@ -121,7 +129,12 @@ function strings(value: unknown, field: string): Record<string, string> {
   const result: Record<string, string> = {}
   for (const [key, entry] of Object.entries(value)) {
     if (!key || typeof entry !== 'string') throw badRequest(field, 'invalid')
-    Object.defineProperty(result, key, { value: entry, enumerable: true, writable: true, configurable: true })
+    Object.defineProperty(result, key, {
+      value: entry,
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    })
   }
   return result
 }
@@ -150,7 +163,8 @@ function cached(value: unknown): McpCachedTool {
   )
     throw badRequest('tools', 'invalid')
   if ([...value.description].length > 1024) throw badRequest('tools', 'too_large')
-  if (new TextEncoder().encode(JSON.stringify(value.schema)).length > 32768) throw badRequest('tools', 'too_large')
+  if (new TextEncoder().encode(JSON.stringify(value.schema)).length > 32768)
+    throw badRequest('tools', 'too_large')
   return {
     name: text(value.name, 'tool'),
     description: value.description,
@@ -163,12 +177,18 @@ function cached(value: unknown): McpCachedTool {
 function toolList(value: unknown): McpCachedTool[] {
   if (!Array.isArray(value) || value.length > 200) throw badRequest('tools', 'invalid')
   const tools = value.map(cached)
-  if (new Set(tools.map((tool) => tool.name)).size !== tools.length) throw badRequest('tools', 'duplicate')
+  if (new Set(tools.map((tool) => tool.name)).size !== tools.length)
+    throw badRequest('tools', 'duplicate')
   return tools
 }
 function readState(value: unknown): State {
   try {
-    if (!object(value) || value.version !== 1 || !Array.isArray(value.servers) || !Array.isArray(value.deleted))
+    if (
+      !object(value) ||
+      value.version !== 1 ||
+      !Array.isArray(value.servers) ||
+      !Array.isArray(value.deleted)
+    )
       throw badRequest('mcp', 'invalid')
     fields(value, ['version', 'servers', 'deleted'], 'mcp')
     const deleted = value.deleted.map((id: unknown) => text(id, 'id'))
@@ -176,7 +196,18 @@ function readState(value: unknown): State {
       if (!object(entry)) throw badRequest('mcp', 'invalid')
       fields(
         entry,
-        ['id', 'slug', 'name', 'url', 'enabled', 'trusted', 'allowPrivate', 'secret', 'secretKeys', 'tools'],
+        [
+          'id',
+          'slug',
+          'name',
+          'url',
+          'enabled',
+          'trusted',
+          'allowPrivate',
+          'secret',
+          'secretKeys',
+          'tools',
+        ],
         'mcp',
       )
       const slug = text(entry.slug, 'slug')
@@ -186,7 +217,8 @@ function readState(value: unknown): State {
         !(entry.secret === null || isSealedCredential(entry.secret))
       )
         throw badRequest('mcp', 'invalid')
-      if (entry.secret !== null) fields(entry.secret, ['version', 'keyId', 'nonce', 'ciphertext'], 'secret')
+      if (entry.secret !== null)
+        fields(entry.secret, ['version', 'keyId', 'nonce', 'ciphertext'], 'secret')
       if (
         new Set(entry.secretKeys).size !== entry.secretKeys.length ||
         (entry.secret !== null && !entry.secretKeys.length)
@@ -211,7 +243,8 @@ function readState(value: unknown): State {
       new Set(servers.map((server) => server.slug)).size !== servers.length ||
       new Set(deleted).size !== deleted.length ||
       servers.some(
-        (server) => deleted.includes(server.id) || (server.secret === null && server.secretKeys.length !== 0),
+        (server) =>
+          deleted.includes(server.id) || (server.secret === null && server.secretKeys.length !== 0),
       )
     )
       throw badRequest('mcp', 'invalid')
@@ -221,7 +254,12 @@ function readState(value: unknown): State {
   }
 }
 function toolDto(tool: McpCachedTool): ToolDto {
-  return { name: tool.name, description: tool.description, readOnly: tool.readOnly, approval: tool.approval }
+  return {
+    name: tool.name,
+    description: tool.description,
+    readOnly: tool.readOnly,
+    approval: tool.approval,
+  }
 }
 function dto(server: Server): ServerDto {
   return {
@@ -288,7 +326,9 @@ export class McpClientSettings {
         const value: unknown = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))
         secret = parseSecret(value)
       } catch {
-        throw new KitFailure('needs_config', 'MCP credentials are unreadable', { reason: 'key_unreadable' })
+        throw new KitFailure('needs_config', 'MCP credentials are unreadable', {
+          reason: 'key_unreadable',
+        })
       } finally {
         bytes?.fill(0)
       }
@@ -326,7 +366,10 @@ export class McpClientSettings {
         const server = snapshot.state.servers.find((entry) => entry.id === id)
         if (!server) throw missing()
         const approvals = new Map(server.tools.map((tool) => [tool.name, tool.approval]))
-        server.tools = toolList(tools).map((tool) => ({ ...tool, approval: approvals.get(tool.name) ?? 'ask' }))
+        server.tools = toolList(tools).map((tool) => ({
+          ...tool,
+          approval: approvals.get(tool.name) ?? 'ask',
+        }))
         await this.commit(owner, snapshot)
       },
     }
@@ -334,18 +377,31 @@ export class McpClientSettings {
     this.runtimes.set(key, runtime)
     return runtime
   }
-  private async save(actor: Actor, input: Record<string, unknown>, id?: string): Promise<ServerDto[]> {
-    fields(input, ['id', 'slug', 'name', 'transport', 'secret', 'enabled', 'trusted', 'allowPrivate'], 'body')
+  private async save(
+    actor: Actor,
+    input: Record<string, unknown>,
+    id?: string,
+  ): Promise<ServerDto[]> {
+    fields(
+      input,
+      ['id', 'slug', 'name', 'transport', 'secret', 'enabled', 'trusted', 'allowPrivate'],
+      'body',
+    )
     if (input.id !== undefined && input.id !== id) throw badRequest('id', 'mismatch')
     const snapshot = await this.snapshot(actor)
-    const existing = id === undefined ? undefined : snapshot.state.servers.find((server) => server.id === id)
+    const existing =
+      id === undefined ? undefined : snapshot.state.servers.find((server) => server.id === id)
     if (id !== undefined && !existing) throw missing()
     const slug = text(input.slug, 'slug')
     if (!/^[a-z0-9_]{1,24}$/.test(slug)) throw badRequest('slug', 'invalid')
     if (snapshot.state.servers.some((server) => server.slug === slug && server.id !== id))
-      throw new KitFailure('conflict', 'MCP slug already exists', { reason: 'duplicate_slug', field: 'slug' })
+      throw new KitFailure('conflict', 'MCP slug already exists', {
+        reason: 'duplicate_slug',
+        field: 'slug',
+      })
     if (!object(input.transport)) throw badRequest('transport', 'invalid')
-    if (input.transport.kind === 'stdio') throw new KitFailure('unsupported', 'Worker MCP clients support HTTP only')
+    if (input.transport.kind === 'stdio')
+      throw new KitFailure('unsupported', 'Worker MCP clients support HTTP only')
     fields(input.transport, ['kind', 'url'], 'transport')
     if (input.transport.kind !== 'http') throw badRequest('transport', 'invalid')
     const allowPrivate = bool(input.allowPrivate, 'allowPrivate', false)
@@ -363,7 +419,9 @@ export class McpClientSettings {
     }
     if (input.secret !== undefined) {
       const secret = parseSecret(input.secret)
-      server.secretKeys = [...new Set([...Object.keys(secret.headers), ...Object.keys(secret.query)])].sort()
+      server.secretKeys = [
+        ...new Set([...Object.keys(secret.headers), ...Object.keys(secret.query)]),
+      ].sort()
       if (server.secretKeys.length) {
         const bytes = new TextEncoder().encode(JSON.stringify(secret))
         try {
@@ -380,7 +438,10 @@ export class McpClientSettings {
   }
   async handle(request: Request, context: WorkerContext): Promise<Response | null> {
     const path = new URL(request.url).pathname
-    const match = /^\/api\/v1\/mcp\/servers(?:\/([^/]+)(?:\/(refresh)|\/tools\/([^/]+)\/(approval))?)?$/.exec(path)
+    const match =
+      /^\/api\/v1\/mcp\/servers(?:\/([^/]+)(?:\/(refresh)|\/tools\/([^/]+)\/(approval))?)?$/.exec(
+        path,
+      )
     if (!match) return null
     let id: string | undefined
     let tool: string | undefined
@@ -391,8 +452,10 @@ export class McpClientSettings {
       throw badRequest('path', 'invalid')
     }
     const actor = context.actor
-    if (!id && request.method === 'GET') return Response.json((await this.snapshot(actor)).state.servers.map(dto))
-    if (!id && request.method === 'POST') return Response.json(await this.save(actor, await body(request)))
+    if (!id && request.method === 'GET')
+      return Response.json((await this.snapshot(actor)).state.servers.map(dto))
+    if (!id && request.method === 'POST')
+      return Response.json(await this.save(actor, await body(request)))
     if (id && !match[2] && !match[4] && request.method === 'PUT')
       return Response.json(await this.save(actor, await body(request), id))
     if (id && !match[2] && !match[4] && request.method === 'DELETE') {
@@ -417,7 +480,9 @@ export class McpClientSettings {
       const server = snapshot.state.servers.find((entry) => entry.id === id)
       const cached = server?.tools.find((entry) => entry.name === tool)
       if (!server || !cached) throw missing()
-      server.tools = server.tools.map((entry) => (entry === cached ? { ...entry, approval: value } : entry))
+      server.tools = server.tools.map((entry) =>
+        entry === cached ? { ...entry, approval: value } : entry,
+      )
       await this.commit(actor, snapshot)
       return Response.json({ ok: true })
     }

package/src/mcp/common.ts

@@ -9,7 +9,8 @@ export function strings(value: unknown): value is string[] {
   return Array.isArray(value) && value.every((item: unknown) => typeof item === 'string')
 }
 export function text(value: unknown, field: string, max = 1024): string {
-  if (typeof value !== 'string' || !value.trim() || value.length > max) throw badRequest(field, 'invalid')
+  if (typeof value !== 'string' || !value.trim() || value.length > max)
+    throw badRequest(field, 'invalid')
   return value
 }
 export function unique(values: readonly string[]): string[] {
@@ -24,7 +25,9 @@ export function base64url(bytes: Uint8Array): string {
   return btoa(value).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/u, '')
 }
 export async function hash(value: string): Promise<string> {
-  return base64url(new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value))))
+  return base64url(
+    new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value))),
+  )
 }
 export function equal(a: string, b: string): boolean {
   let difference = a.length ^ b.length
@@ -33,7 +36,8 @@ export function equal(a: string, b: string): boolean {
   return difference === 0
 }
 export async function body(request: Request, max = 65536): Promise<string> {
-  if (Number(request.headers.get('Content-Length')) > max) throw badRequest('body', 'too_large', max)
+  if (Number(request.headers.get('Content-Length')) > max)
+    throw badRequest('body', 'too_large', max)
   if (!request.body) return ''
   const reader = request.body.getReader()
   const chunks: Uint8Array[] = []