@ouraihub/aether-worker 0.1.0 → 0.1.1

package/src/mcp/index.ts

@@ -26,7 +26,11 @@ function rpc(id: unknown, result: unknown, error = false): Response {
     ...(error ? { error: result } : { result }),
   }
   if (encoder.encode(JSON.stringify(message)).byteLength > MAX_RESULT_BYTES)
-    return json({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'Result budget exceeded' } })
+    return json({
+      jsonrpc: '2.0',
+      id: message.id,
+      error: { code: -32603, message: 'Result budget exceeded' },
+    })
   return json(message)
 }
 function rpcError(id: unknown, code: number, message: string): Response {
@@ -79,7 +83,8 @@ export class McpService {
       !url.pathname.startsWith('/.well-known/oauth-')
     )
       return null
-    if (url.origin !== this.options.origin || url.protocol !== 'https:') return json({ error: 'invalid_request' }, 400)
+    if (url.origin !== this.options.origin || url.protocol !== 'https:')
+      return json({ error: 'invalid_request' }, 400)
     if (url.pathname === '/mcp') return this.mcp(request)
     return this.oauth.handle(request)
   }
@@ -99,12 +104,18 @@ export class McpService {
           !value.enabledScopes.every((scope: unknown) => typeof scope === 'string')
         )
           throw badRequest('enabledScopes', 'invalid')
-        const requested = value.enabledScopes.length ? this.auth.requested(value.enabledScopes, context.actor) : []
+        const requested = value.enabledScopes.length
+          ? this.auth.requested(value.enabledScopes, context.actor)
+          : []
         if (!(await this.options.authorizeConsent(context.actor, requested, request))) forbidden()
-        return json({ ...(await this.auth.saveSettings(context.actor, value)), scopes: this.options.scopes })
+        return json({
+          ...(await this.auth.saveSettings(context.actor, value)),
+          scopes: this.options.scopes,
+        })
       }
     }
-    if (path === '/api/v1/mcp/grants' && request.method === 'GET') return json(await this.auth.grants(context.actor))
+    if (path === '/api/v1/mcp/grants' && request.method === 'GET')
+      return json(await this.auth.grants(context.actor))
     if (path === '/api/v1/mcp/api-keys') {
       if (request.method === 'GET') return json(await this.auth.keys(context.actor))
       if (request.method === 'POST')
@@ -114,26 +125,43 @@ export class McpService {
     if (revoke && request.method === 'POST') {
       const id = revoke[2]
       if (!id) throw badRequest('id', 'invalid')
-      await this.auth.revoke(context.actor, revoke[1] === 'grants' ? 'grant' : 'key', decodeURIComponent(id))
+      await this.auth.revoke(
+        context.actor,
+        revoke[1] === 'grants' ? 'grant' : 'key',
+        decodeURIComponent(id),
+      )
       return json({ ok: true })
     }
     return json({ code: 'not_found', message: 'Route not found' }, 404)
   }
   private async mcp(request: Request): Promise<Response> {
     const origin = request.headers.get('Origin')
-    if (origin !== null && ![this.options.origin, ...(this.options.mcpOrigins ?? [])].includes(origin))
+    if (
+      origin !== null &&
+      ![this.options.origin, ...(this.options.mcpOrigins ?? [])].includes(origin)
+    )
       return json({ error: 'forbidden' }, 403)
-    if (request.method !== 'POST') return new Response(null, { status: 405, headers: { Allow: 'POST' } })
+    if (request.method !== 'POST')
+      return new Response(null, { status: 405, headers: { Allow: 'POST' } })
+    const requiresAccess = this.options.scopes.some((scope) => scope.id === 'mcp:access')
+    const challenge =
+      `Bearer resource_metadata="${this.options.origin}/.well-known/oauth-protected-resource/mcp"` +
+      (requiresAccess ? ', scope="mcp:access"' : '')
     const bearer = /^Bearer[\t ]+([^\s,]+)$/iu.exec(request.headers.get('Authorization') ?? '')?.[1]
     const authentication = bearer ? await this.auth.authenticate(bearer) : null
     if (!authentication)
       return json({ error: 'unauthorized' }, 401, {
-        'WWW-Authenticate': `Bearer resource_metadata="${this.options.origin}/.well-known/oauth-protected-resource"`,
+        'WWW-Authenticate': challenge,
+      })
+    if (requiresAccess && !authentication.scopes.includes('mcp:access'))
+      return json({ error: 'insufficient_scope' }, 403, {
+        'WWW-Authenticate': `${challenge}, error="insufficient_scope"`,
       })
-    if (this.options.scopes.some((scope) => scope.id === 'mcp:access') && !authentication.scopes.includes('mcp:access'))
-      return json({ error: 'forbidden' }, 403)
     const maxBytes =
-      this.options.tools.reduce((max, tool) => Math.max(max, tool.maxRequestBytes ?? 65536), 65536) + 8192
+      this.options.tools.reduce(
+        (max, tool) => Math.max(max, tool.maxRequestBytes ?? 65536),
+        65536,
+      ) + 8192
     let message: unknown
     try {
       message = JSON.parse(await body(request, maxBytes))
@@ -146,20 +174,32 @@ export class McpService {
       !object(message) ||
       message.jsonrpc !== '2.0' ||
       typeof message.method !== 'string' ||
-      ('id' in message && typeof message.id !== 'string' && typeof message.id !== 'number' && message.id !== null)
+      ('id' in message &&
+        typeof message.id !== 'string' &&
+        typeof message.id !== 'number' &&
+        message.id !== null)
     )
       return rpcError(null, -32600, 'Invalid request')
     if (!('id' in message)) {
-      if (message.method === 'notifications/initialized' || message.method === 'notifications/cancelled')
+      if (
+        message.method === 'notifications/initialized' ||
+        message.method === 'notifications/cancelled'
+      )
         return new Response(null, { status: 202 })
       return rpcError(null, -32600, 'Invalid request')
     }
     const id = message.id
     if (message.method === 'initialize') {
-      if (!object(message.params) || !['2024-11-05', '2025-03-26'].includes(String(message.params.protocolVersion)))
-        return rpcError(id, -32602, 'Unsupported protocol version')
+      if (
+        !object(message.params) ||
+        typeof message.params.protocolVersion !== 'string' ||
+        !message.params.protocolVersion.trim()
+      )
+        return rpcError(id, -32602, 'Invalid protocol version')
       return rpc(id, {
-        protocolVersion: message.params.protocolVersion,
+        protocolVersion: ['2024-11-05', '2025-03-26'].includes(message.params.protocolVersion)
+          ? message.params.protocolVersion
+          : '2025-03-26',
         capabilities: { tools: {} },
         serverInfo: { name: 'Aether MCP', version: '1.0.0' },
       })
@@ -208,18 +248,31 @@ export class McpService {
       if (signal.aborted || !(await this.options.authorizeTool(auth.actor, tool, args, signal)))
         return rpcError(id, -32001, 'Forbidden')
       if (signal.aborted) return rpcError(id, -32603, 'Cancelled')
-      const result = await tool.handler(args, { actor: auth.actor, tokenId: auth.tokenId, scopes: auth.scopes, signal })
+      const result = await tool.handler(args, {
+        actor: auth.actor,
+        tokenId: auth.tokenId,
+        scopes: auth.scopes,
+        signal,
+      })
       if (result === undefined) throw new KitFailure('internal', 'Invalid tool result')
       const payload = object(result)
-        ? { content: [{ type: 'text', text: JSON.stringify(result) }], structuredContent: result, isError: false }
+        ? {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+            structuredContent: result,
+            isError: false,
+          }
         : {
-            content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }],
+            content: [
+              { type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) },
+            ],
             isError: false,
           }
       const serialized = JSON.stringify({ jsonrpc: '2.0', id, result: payload })
       if (encoder.encode(serialized).byteLength > MAX_RESULT_BYTES)
         return rpcError(id, -32603, 'Result budget exceeded')
-      return new Response(serialized, { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' } })
+      return new Response(serialized, {
+        headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' },
+      })
     } catch (error) {
       const safe = safeError(error)
       const code =

package/src/mcp/oauth.ts

@@ -53,7 +53,10 @@ function redirectAllowed(value: string): boolean {
   }
 }
 function redirect(target: string): Response {
-  return new Response(null, { status: 302, headers: { Location: target, 'Cache-Control': 'no-store' } })
+  return new Response(null, {
+    status: 302,
+    headers: { Location: target, 'Cache-Control': 'no-store' },
+  })
 }
 
 export class McpOAuth {
@@ -67,7 +70,11 @@ export class McpOAuth {
     const url = new URL(request.url)
     const origin = this.options.origin
     const resource = `${origin}/mcp`
-    if (url.pathname === '/.well-known/oauth-protected-resource' && request.method === 'GET')
+    if (
+      (url.pathname === '/.well-known/oauth-protected-resource' ||
+        url.pathname === '/.well-known/oauth-protected-resource/mcp') &&
+      request.method === 'GET'
+    )
       return json({
         resource,
         authorization_servers: [origin],
@@ -86,15 +93,22 @@ export class McpOAuth {
         token_endpoint_auth_methods_supported: ['none'],
         scopes_supported: this.options.scopes.map((scope) => scope.id),
       })
-    if (url.pathname === '/oauth/register' && request.method === 'POST') return this.register(request)
-    if (url.pathname === '/oauth/authorize' && (request.method === 'GET' || request.method === 'POST'))
+    if (url.pathname === '/oauth/register' && request.method === 'POST')
+      return this.register(request)
+    if (
+      url.pathname === '/oauth/authorize' &&
+      (request.method === 'GET' || request.method === 'POST')
+    )
       return this.authorize(request)
     if (url.pathname === '/oauth/token' && request.method === 'POST') {
       try {
         return await this.token(request)
       } catch (error) {
         if (!(error instanceof KitFailure)) throw error
-        return json({ error: error.code === 'bad_request' ? 'invalid_request' : 'invalid_grant' }, 400)
+        return json(
+          { error: error.code === 'bad_request' ? 'invalid_request' : 'invalid_grant' },
+          400,
+        )
       }
     }
     if (url.pathname.startsWith('/oauth/') || url.pathname.startsWith('/.well-known/oauth-'))
@@ -110,7 +124,10 @@ export class McpOAuth {
       input.redirect_uris.some((uri) => uri.length > 2048 || !redirectAllowed(uri))
     )
       throw badRequest('redirect_uris', 'invalid')
-    if (input.token_endpoint_auth_method !== undefined && input.token_endpoint_auth_method !== 'none')
+    if (
+      input.token_endpoint_auth_method !== undefined &&
+      input.token_endpoint_auth_method !== 'none'
+    )
       throw badRequest('token_endpoint_auth_method', 'unsupported')
     if (
       input.grant_types !== undefined &&
@@ -123,7 +140,10 @@ export class McpOAuth {
       (!strings(input.response_types) || input.response_types.some((type) => type !== 'code'))
     )
       throw badRequest('response_types', 'unsupported')
-    if (input.client_name !== undefined && (typeof input.client_name !== 'string' || input.client_name.length > 128))
+    if (
+      input.client_name !== undefined &&
+      (typeof input.client_name !== 'string' || input.client_name.length > 128)
+    )
       throw badRequest('client_name', 'invalid')
     const record: OAuthClient = {
       id: crypto.randomUUID(),
@@ -157,18 +177,31 @@ export class McpOAuth {
       'resource',
     ])
       if (query.getAll(key).length > 1) throw badRequest(key, 'duplicate')
-    const record = await this.options.store.get(this.auth.system, 'mcp-clients', query.get('client_id') ?? '')
+    const record = await this.options.store.get(
+      this.auth.system,
+      'mcp-clients',
+      query.get('client_id') ?? '',
+    )
     if (!record || !client(record.value)) throw badRequest('client_id', 'invalid')
     const redirectUri = query.get('redirect_uri') ?? ''
-    if (!record.value.redirectUris.includes(redirectUri)) throw badRequest('redirect_uri', 'mismatch')
+    if (!record.value.redirectUris.includes(redirectUri))
+      throw badRequest('redirect_uri', 'mismatch')
     if (query.get('response_type') !== 'code' || query.get('code_challenge_method') !== 'S256')
       throw badRequest('response_type', 'unsupported')
     const challenge = query.get('code_challenge') ?? ''
     if (!/^[A-Za-z0-9_-]{43}$/u.test(challenge)) throw badRequest('code_challenge', 'invalid')
     const resource = `${this.options.origin}/mcp`
-    if (query.has('resource') && query.get('resource') !== resource) throw badRequest('resource', 'invalid')
+    if (query.has('resource') && query.get('resource') !== resource)
+      throw badRequest('resource', 'invalid')
     const scopes = this.auth.requested((query.get('scope') ?? '').split(/\s+/u).filter(Boolean))
-    return { client: record.value, redirectUri, scopes, challenge, state: query.get('state') ?? '', resource }
+    return {
+      client: record.value,
+      redirectUri,
+      scopes,
+      challenge,
+      state: query.get('state') ?? '',
+      resource,
+    }
   }
   private async authorize(request: Request): Promise<Response> {
     const parsed = await this.parse(request)
@@ -178,7 +211,8 @@ export class McpOAuth {
     this.auth.actor(actor)
     this.auth.requested(parsed.scopes, actor)
     const settings = await this.auth.settings(actor)
-    if (!settings.enabled || parsed.scopes.some((scope) => !settings.enabledScopes.includes(scope))) forbidden()
+    if (!settings.enabled || parsed.scopes.some((scope) => !settings.enabledScopes.includes(scope)))
+      forbidden()
     const requestHash = await hash(new URL(request.url).searchParams.toString())
     if (request.method === 'GET') {
       const csrf = random()
@@ -196,7 +230,8 @@ export class McpOAuth {
         headers: {
           'Content-Type': 'text/html; charset=utf-8',
           'Cache-Control': 'no-store',
-          'Content-Security-Policy': "default-src 'none'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'",
+          'Content-Security-Policy':
+            "default-src 'none'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'",
           'Referrer-Policy': 'no-referrer',
           'X-Content-Type-Options': 'nosniff',
         },
@@ -222,11 +257,19 @@ export class McpOAuth {
     })
     const target = new URL(parsed.redirectUri)
     if (parsed.state) target.searchParams.set('state', parsed.state)
-    if (form.get('decision') !== 'approve' || !(await this.options.authorizeConsent(actor, parsed.scopes, request))) {
+    if (
+      form.get('decision') !== 'approve' ||
+      !(await this.options.authorizeConsent(actor, parsed.scopes, request))
+    ) {
       target.searchParams.set('error', 'access_denied')
       return redirect(target.toString())
     }
-    const grant = await this.auth.createGrant(actor, parsed.client.id, parsed.redirectUri, parsed.scopes)
+    const grant = await this.auth.createGrant(
+      actor,
+      parsed.client.id,
+      parsed.redirectUri,
+      parsed.scopes,
+    )
     const code = random()
     await this.options.store.compareAndSet(this.auth.system, 'mcp-codes', await hash(code), null, {
       owner: actor,
@@ -242,10 +285,15 @@ export class McpOAuth {
     return redirect(target.toString())
   }
   private async form(request: Request): Promise<URLSearchParams> {
-    if (!(request.headers.get('Content-Type') ?? '').toLowerCase().startsWith('application/x-www-form-urlencoded'))
+    if (
+      !(request.headers.get('Content-Type') ?? '')
+        .toLowerCase()
+        .startsWith('application/x-www-form-urlencoded')
+    )
       throw badRequest('body', 'form_required')
     const form = new URLSearchParams(await body(request, 16384))
-    for (const key of new Set(form.keys())) if (form.getAll(key).length !== 1) throw badRequest(key, 'duplicate')
+    for (const key of new Set(form.keys()))
+      if (form.getAll(key).length !== 1) throw badRequest(key, 'duplicate')
     return form
   }
   private async token(request: Request): Promise<Response> {
@@ -255,8 +303,13 @@ export class McpOAuth {
       throw badRequest('resource', 'invalid')
     if (form.get('grant_type') === 'refresh_token')
       return json(await this.auth.refresh(form.get('refresh_token') ?? '', clientId))
-    if (form.get('grant_type') !== 'authorization_code') throw badRequest('grant_type', 'unsupported')
-    const document = await this.options.store.get(this.auth.system, 'mcp-codes', await hash(form.get('code') ?? ''))
+    if (form.get('grant_type') !== 'authorization_code')
+      throw badRequest('grant_type', 'unsupported')
+    const document = await this.options.store.get(
+      this.auth.system,
+      'mcp-codes',
+      await hash(form.get('code') ?? ''),
+    )
     if (!document || !object(document.value)) throw new KitFailure('unauthorized', 'Invalid grant')
     const value = document.value
     const verifier = form.get('code_verifier') ?? ''
@@ -275,10 +328,16 @@ export class McpOAuth {
       !equal(await hash(verifier), value.challenge)
     )
       throw new KitFailure('unauthorized', 'Invalid grant')
-    await this.options.store.compareAndSet(this.auth.system, 'mcp-codes', document.key, document.revision, {
-      ...value,
-      used: true,
-    })
+    await this.options.store.compareAndSet(
+      this.auth.system,
+      'mcp-codes',
+      document.key,
+      document.revision,
+      {
+        ...value,
+        used: true,
+      },
+    )
     return json(await this.auth.issueTokens(value.owner, value.grantId, undefined, clientId))
   }
 }

package/src/mcp/types.ts

@@ -18,7 +18,10 @@ export interface ExposedMcpTool {
   readonly idempotent: boolean
   readonly maxRequestBytes?: number
   readonly validate: (args: Readonly<Record<string, unknown>>) => boolean
-  readonly handler: (args: Readonly<Record<string, unknown>>, context: McpCallContext) => Promise<unknown>
+  readonly handler: (
+    args: Readonly<Record<string, unknown>>,
+    context: McpCallContext,
+  ) => Promise<unknown>
 }
 export interface McpCallContext {
   readonly actor: Actor
@@ -36,7 +39,11 @@ export interface McpServiceOptions {
   readonly tools: readonly ExposedMcpTool[]
   readonly resolveIdentity: (request: Request) => Promise<Actor | null>
   /** Must check the actor may grant every requested scope, not just that login exists. */
-  readonly authorizeConsent: (actor: Actor, scopes: readonly string[], request: Request) => Promise<boolean>
+  readonly authorizeConsent: (
+    actor: Actor,
+    scopes: readonly string[],
+    request: Request,
+  ) => Promise<boolean>
   /** Must check resource/business access immediately before external tool dispatch. */
   readonly authorizeTool: (
     actor: Actor,

package/src/outbound.ts

@@ -48,7 +48,12 @@ function privateLiteral(host: string): boolean {
     )
   }
   if (!/^\d+(?:\.\d+){3}$/u.test(host))
-    return host === 'localhost' || host.endsWith('.localhost') || host.endsWith('.local') || !host.includes('.')
+    return (
+      host === 'localhost' ||
+      host.endsWith('.localhost') ||
+      host.endsWith('.local') ||
+      !host.includes('.')
+    )
   const parts = host.split('.').map(Number)
   const a = parts[0],
     b = parts[1],
@@ -81,11 +86,13 @@ export function createWorkerOutbound(options: WorkerOutboundOptions): OutboundHt
       } catch {
         throw badRequest('allowedOrigins', 'invalid')
       }
-      if (url.origin !== origin || url.username || url.password) throw badRequest('allowedOrigins', 'invalid')
+      if (url.origin !== origin || url.username || url.password)
+        throw badRequest('allowedOrigins', 'invalid')
       return origin
     }),
   )
-  if (origins.size === 0) throw new KitFailure('needs_config', 'Outbound origins must be explicitly configured')
+  if (origins.size === 0)
+    throw new KitFailure('needs_config', 'Outbound origins must be explicitly configured')
   const privateOrigins = new Set(options.privateGateway?.allowedOrigins ?? [])
   for (const origin of privateOrigins) {
     let target: URL
@@ -126,7 +133,9 @@ export function createWorkerOutbound(options: WorkerOutboundOptions): OutboundHt
         !local &&
         (!gateway ||
           gateway.security !==
-            (privateTarget ? 'explicit-private-targets-at-connect-time' : 'public-addresses-at-connect-time'))
+            (privateTarget
+              ? 'explicit-private-targets-at-connect-time'
+              : 'public-addresses-at-connect-time'))
       )
         throw new KitFailure('needs_config', 'Trusted connect-time outbound gateway is required')
       const abort = new AbortController()
@@ -169,7 +178,8 @@ export function createWorkerOutbound(options: WorkerOutboundOptions): OutboundHt
       init.signal?.addEventListener('abort', callerAbort, { once: true })
       abort.signal.addEventListener('abort', onAbort, { once: true })
       if (init.signal?.aborted) callerAbort()
-      if (abort.signal.aborted) throw failure ?? new KitFailure('cancelled', 'Outbound request cancelled')
+      if (abort.signal.aborted)
+        throw failure ?? new KitFailure('cancelled', 'Outbound request cancelled')
       try {
         const headers = new Headers(init.headers)
         headers.set('User-Agent', 'Aether-Worker/1')
@@ -184,7 +194,8 @@ export function createWorkerOutbound(options: WorkerOutboundOptions): OutboundHt
         const pending = local
           ? (options.localFetch ?? fetch)(target.href, request)
           : gateway?.binding.fetch(target.href, request)
-        if (!pending) throw new KitFailure('needs_config', 'Trusted connect-time outbound gateway is required')
+        if (!pending)
+          throw new KitFailure('needs_config', 'Trusted connect-time outbound gateway is required')
         void pending.then(
           (response) => {
             if (abort.signal.aborted) void response.body?.cancel().catch(() => {})
@@ -192,7 +203,8 @@ export function createWorkerOutbound(options: WorkerOutboundOptions): OutboundHt
           () => {},
         )
         const aborted = Promise.withResolvers<never>()
-        const rejectAbort = () => aborted.reject(failure ?? new KitFailure('cancelled', 'Outbound request cancelled'))
+        const rejectAbort = () =>
+          aborted.reject(failure ?? new KitFailure('cancelled', 'Outbound request cancelled'))
         abort.signal.addEventListener('abort', rejectAbort, { once: true })
         let response: Response
         try {
@@ -209,7 +221,10 @@ export function createWorkerOutbound(options: WorkerOutboundOptions): OutboundHt
           throw badRequest('url', 'redirect_forbidden')
         }
         const length = response.headers.get('content-length')
-        if (length !== null && (!/^\d+$/u.test(length) || Number(length) > limits.maxResponseBytes)) {
+        if (
+          length !== null &&
+          (!/^\d+$/u.test(length) || Number(length) > limits.maxResponseBytes)
+        ) {
           void response.body?.cancel().catch(() => {})
           throw badRequest('response', 'too_large', limits.maxResponseBytes)
         }

package/src/providers/catalog.ts

@@ -0,0 +1,63 @@
+import { isContract, type Provider } from '@ouraihub/aether-contracts'
+import { KitFailure } from '@ouraihub/aether-core/error'
+import { inferReasoning } from '@ouraihub/aether-core/providers/infer'
+import { isSealedCredential, type SealedCredential } from '../credentials.js'
+
+export interface Secret {
+  endpointId: string
+  keyId: string
+  sealed: SealedCredential
+}
+
+export interface Catalog {
+  providers: Provider[]
+  secrets: Secret[]
+  inferred: string[]
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function parseCatalog(value: unknown): Catalog {
+  if (
+    !record(value) ||
+    !Array.isArray(value.providers) ||
+    !Array.isArray(value.secrets) ||
+    !Array.isArray(value.inferred)
+  )
+    throw new KitFailure('incompatible_db', 'Invalid provider catalog')
+  const providers: Provider[] = []
+  const secrets: Secret[] = []
+  const inferred: string[] = []
+  for (const item of value.providers) {
+    if (!isContract('Provider', item))
+      throw new KitFailure('incompatible_db', 'Invalid provider document')
+    providers.push(item)
+  }
+  for (const item of value.secrets) {
+    if (
+      !record(item) ||
+      typeof item.endpointId !== 'string' ||
+      typeof item.keyId !== 'string' ||
+      !isSealedCredential(item.sealed)
+    )
+      throw new KitFailure('incompatible_db', 'Invalid provider credential')
+    secrets.push({ endpointId: item.endpointId, keyId: item.keyId, sealed: item.sealed })
+  }
+  for (const item of value.inferred) {
+    if (typeof item !== 'string')
+      throw new KitFailure('incompatible_db', 'Invalid reasoning declaration')
+    inferred.push(item)
+  }
+  const automatic = new Set(inferred)
+  for (const provider of providers)
+    for (const endpoint of provider.endpoints)
+      for (const model of endpoint.models)
+        if (automatic.has(JSON.stringify([endpoint.id, model.id])))
+          model.reasoning =
+            model.modelType === 'chat'
+              ? inferReasoning(model.id, endpoint.protocol, endpoint.baseUrl, model.maxOutput)
+              : null
+  return { providers, secrets, inferred }
+}

package/src/providers/http.ts

@@ -0,0 +1,88 @@
+import {
+  isContract,
+  type ModelFilter,
+  type ProviderSave,
+  type EndpointKeySave,
+  type ProbeTarget,
+} from '@ouraihub/aether-contracts'
+import { KitFailure, badRequest } from '@ouraihub/aether-core/error'
+import type { WorkerContext } from '../context.js'
+import type { ProviderService } from './index.js'
+
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export async function handleProviderRequest(
+  service: ProviderService,
+  request: Request,
+  context: WorkerContext,
+  authorizeReveal: (request: Request, context: WorkerContext) => Promise<void>,
+): Promise<Response | null> {
+  const url = new URL(request.url)
+  const path = url.pathname
+  const root = '/api/v1/providers'
+  if (path !== root && !path.startsWith(`${root}/`)) return null
+  const actor = context.actor
+  const json = (value: unknown): Response => Response.json(value)
+  if (path === root && request.method === 'GET') return json(await service.list(actor))
+  if (path === root && request.method === 'POST') {
+    const value: unknown = await request.json()
+    if (!isContract('ProviderSave', value)) throw badRequest('provider', 'invalid')
+    return json(await service.save(actor, value as ProviderSave))
+  }
+  if (path === `${root}/model-options` && request.method === 'GET') {
+    const value: unknown = {
+      ...(url.searchParams.has('modelType')
+        ? { modelType: url.searchParams.get('modelType') }
+        : {}),
+      ...(url.searchParams.has('supportsTools')
+        ? { supportsTools: url.searchParams.get('supportsTools') === 'true' }
+        : {}),
+    }
+    if (
+      url.searchParams.has('supportsTools') &&
+      !['true', 'false'].includes(url.searchParams.get('supportsTools') ?? '')
+    )
+      throw badRequest('supportsTools', 'invalid')
+    if (!isContract('ModelFilter', value)) throw badRequest('filter', 'invalid')
+    return json(await service.modelOptions(actor, value as ModelFilter))
+  }
+  if (path === `${root}/probe` && request.method === 'POST') {
+    const value: unknown = await request.json()
+    if (!isContract('ProbeTarget', value)) throw badRequest('target', 'invalid')
+    return json(await service.probe(actor, value as ProbeTarget, context.signal))
+  }
+  if (path === `${root}/keys` && request.method === 'POST') {
+    const value: unknown = await request.json()
+    if (!isContract('EndpointKeySave', value)) throw badRequest('key', 'invalid')
+    return json(await service.saveKey(actor, value as EndpointKeySave))
+  }
+  const reveal = path.match(/^\/api\/v1\/providers\/keys\/([^/]+)\/reveal$/)
+  if (reveal && request.method === 'POST') {
+    await authorizeReveal(request, context)
+    return json(await service.revealKey(actor, decodeURIComponent(reveal[1] ?? '')))
+  }
+  const key = path.match(/^\/api\/v1\/providers\/([^/]+)\/keys\/([^/]+)$/)
+  if (key && request.method === 'DELETE')
+    return json(
+      await service.removeKey(
+        actor,
+        decodeURIComponent(key[1] ?? ''),
+        decodeURIComponent(key[2] ?? ''),
+      ),
+    )
+  const enabled = path.match(/^\/api\/v1\/providers\/([^/]+)\/enabled$/)
+  if (enabled && request.method === 'POST') {
+    const value: unknown = await request.json()
+    if (!record(value) || Object.keys(value).length !== 1 || typeof value.enabled !== 'boolean')
+      throw badRequest('enabled', 'invalid')
+    return json(
+      await service.setEnabled(actor, decodeURIComponent(enabled[1] ?? ''), value.enabled),
+    )
+  }
+  const provider = path.match(/^\/api\/v1\/providers\/([^/]+)$/)
+  if (provider && request.method === 'DELETE')
+    return json(await service.remove(actor, decodeURIComponent(provider[1] ?? '')))
+  throw new KitFailure('not_found', 'Unknown route', { entity: 'route' })
+}