@ouraihub/aether-worker 0.1.0 → 0.1.1

package/src/providers/index.ts

@@ -13,6 +13,8 @@ import {
   type ProviderSave,
 } from '@ouraihub/aether-contracts'
 import { KitFailure, badRequest } from '@ouraihub/aether-core/error'
+import { inferReasoning } from '@ouraihub/aether-core/providers/infer'
+import { probe as probeEndpoint } from '@ouraihub/aether-core/providers/probe'
 import {
   prepare,
   validateHeaders,
@@ -22,75 +24,26 @@ import {
   charCount,
   type EndpointSnapshot,
 } from '@ouraihub/aether-core/providers/connection'
-import { inferReasoning } from '@ouraihub/aether-core/providers/infer'
-import { probe as probeEndpoint } from '@ouraihub/aether-core/providers/probe'
 import type { Connection } from '@ouraihub/aether-core/types'
 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 type { CredentialPort, CredentialScope, SealedCredential } from '../credentials.js'
 import type { DocumentStore, StoredDocument } from '../storage.js'
+import { parseCatalog, type Catalog, type Secret } from './catalog.js'
+import { modelOptions } from './model-options.js'
+import { handleProviderRequest } from './http.js'
 
-interface Secret {
-  endpointId: string
-  keyId: string
-  sealed: SealedCredential
-}
-interface Catalog {
-  providers: Provider[]
-  secrets: Secret[]
-  inferred: string[]
-}
 export interface ProviderServiceOptions {
   documents: DocumentStore
   credentials: CredentialPort
   outbound: OutboundHttp
   authorizeReveal: (request: Request, context: WorkerContext) => Promise<void>
 }
-function record(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-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 }
-}
-const missing = (entity: string): KitFailure => new KitFailure('not_found', `Unknown ${entity}`, { entity })
-const reasoningKey = (endpointId: string, modelId: string): string => JSON.stringify([endpointId, modelId])
+
+const missing = (entity: string): KitFailure =>
+  new KitFailure('not_found', `Unknown ${entity}`, { entity })
+const reasoningKey = (endpointId: string, modelId: string): string =>
+  JSON.stringify([endpointId, modelId])
 export class ProviderService {
   private readonly cursors = new Map<string, number>()
   private readonly options: ProviderServiceOptions
@@ -108,13 +61,31 @@ export class ProviderService {
   }
   private async load(actor: Actor): Promise<{ document: StoredDocument | null; catalog: Catalog }> {
     const document = await this.options.documents.get(actor, 'providers', 'catalog')
-    return { document, catalog: document ? parseCatalog(document.value) : { providers: [], secrets: [], inferred: [] } }
+    return {
+      document,
+      catalog: document
+        ? parseCatalog(document.value)
+        : { providers: [], secrets: [], inferred: [] },
+    }
   }
-  private async commit(actor: Actor, document: StoredDocument | null, catalog: Catalog): Promise<Provider[]> {
-    await this.options.documents.compareAndSet(actor, 'providers', 'catalog', document?.revision ?? null, catalog)
+  private async commit(
+    actor: Actor,
+    document: StoredDocument | null,
+    catalog: Catalog,
+  ): Promise<Provider[]> {
+    await this.options.documents.compareAndSet(
+      actor,
+      'providers',
+      'catalog',
+      document?.revision ?? null,
+      catalog,
+    )
     return this.list(actor)
   }
-  private endpoint(catalog: Catalog, endpointId: string): { provider: Provider; endpoint: Endpoint } {
+  private endpoint(
+    catalog: Catalog,
+    endpointId: string,
+  ): { provider: Provider; endpoint: Endpoint } {
     for (const provider of catalog.providers) {
       const endpoint = provider.endpoints.find((item) => item.id === endpointId)
       if (endpoint) return { provider, endpoint }
@@ -122,7 +93,10 @@ export class ProviderService {
     throw missing('endpoint')
   }
   private async open(actor: Actor, secret: Secret): Promise<string> {
-    const bytes = await this.options.credentials.open(this.scope(actor, secret.keyId), secret.sealed)
+    const bytes = await this.options.credentials.open(
+      this.scope(actor, secret.keyId),
+      secret.sealed,
+    )
     try {
       return new TextDecoder('utf-8', { fatal: true }).decode(bytes)
     } finally {
@@ -134,7 +108,9 @@ export class ProviderService {
     for (const provider of catalog.providers)
       for (const endpoint of provider.endpoints)
         for (const key of endpoint.keys) {
-          const secret = catalog.secrets.find((item) => item.endpointId === endpoint.id && item.keyId === key.id)
+          const secret = catalog.secrets.find(
+            (item) => item.endpointId === endpoint.id && item.keyId === key.id,
+          )
           let plain: string | null = null
           if (secret)
             try {
@@ -143,7 +119,12 @@ export class ProviderService {
               /* Unreadable credentials remain visible but cannot execute. */
             }
           key.readable = plain !== null
-          key.masked = plain === null ? null : plain.length > 8 ? `${plain.slice(0, 4)}…${plain.slice(-4)}` : '********'
+          key.masked =
+            plain === null
+              ? null
+              : plain.length > 8
+                ? `${plain.slice(0, 4)}…${plain.slice(-4)}`
+                : '********'
         }
     return catalog.providers
   }
@@ -152,10 +133,12 @@ export class ProviderService {
     const { document, catalog } = await this.load(actor)
     const name = input.name.trim()
     if (!name || charCount(name) > 80) throw badRequest('name', 'invalid')
-    if (input.notes !== undefined && charCount(input.notes) > 10000) throw badRequest('notes', 'too_long', 10000)
+    if (input.notes !== undefined && charCount(input.notes) > 10000)
+      throw badRequest('notes', 'too_long', 10000)
     if (input.endpoints.length > 20) throw badRequest('endpoints', 'too_many', 20)
     if (input.presetId && !input.id) {
-      if (catalog.providers.some((item) => item.presetId === input.presetId)) return this.list(actor)
+      if (catalog.providers.some((item) => item.presetId === input.presetId))
+        return this.list(actor)
       const adopted = catalog.providers.find((item) => item.name === name && item.presetId === null)
       if (adopted) {
         adopted.presetId = input.presetId
@@ -164,7 +147,8 @@ export class ProviderService {
     }
     const old = input.id ? catalog.providers.find((item) => item.id === input.id) : undefined
     if (input.id && !old) throw missing('provider')
-    if (input.presetId && old && input.presetId !== old.presetId) throw badRequest('presetId', 'immutable')
+    if (input.presetId && old && input.presetId !== old.presetId)
+      throw badRequest('presetId', 'immutable')
     const provider: Provider = {
       id: old?.id ?? crypto.randomUUID(),
       name,
@@ -178,7 +162,8 @@ export class ProviderService {
     const endpointIds = new Set<string>()
     const inferred = new Set(catalog.inferred)
     for (const saved of input.endpoints) {
-      if (!/^[a-z0-9-]{1,40}$/.test(saved.slug) || slugs.has(saved.slug)) throw badRequest('slug', 'invalid')
+      if (!/^[a-z0-9-]{1,40}$/.test(saved.slug) || slugs.has(saved.slug))
+        throw badRequest('slug', 'invalid')
       slugs.add(saved.slug)
       const previous = saved.id ? old?.endpoints.find((item) => item.id === saved.id) : undefined
       if (saved.id && !previous) throw missing('endpoint')
@@ -237,11 +222,15 @@ export class ProviderService {
     catalog.providers = old
       ? catalog.providers.map((item) => (item.id === old.id ? provider : item))
       : [...catalog.providers, provider]
-    const allEndpoints = new Set(catalog.providers.flatMap((item) => item.endpoints.map((endpoint) => endpoint.id)))
+    const allEndpoints = new Set(
+      catalog.providers.flatMap((item) => item.endpoints.map((endpoint) => endpoint.id)),
+    )
     catalog.secrets = catalog.secrets.filter((item) => allEndpoints.has(item.endpointId))
     catalog.inferred = [...inferred].filter((key) =>
       catalog.providers.some((item) =>
-        item.endpoints.some((endpoint) => endpoint.models.some((model) => reasoningKey(endpoint.id, model.id) === key)),
+        item.endpoints.some((endpoint) =>
+          endpoint.models.some((model) => reasoningKey(endpoint.id, model.id) === key),
+        ),
       ),
     )
     return this.commit(actor, document, catalog)
@@ -285,7 +274,9 @@ export class ProviderService {
       if (!plain) throw badRequest('apiKey', 'empty')
       if (
         new TextEncoder().encode(plain).length > 4096 ||
-        [...plain].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)
+        [...plain].some(
+          (character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127,
+        )
       )
         throw badRequest('apiKey', 'too_long', 4096)
       for (const secret of catalog.secrets)
@@ -294,7 +285,9 @@ export class ProviderService {
           try {
             existing = await this.open(actor, secret)
           } catch {
-            throw new KitFailure('needs_config', 'Credential cannot be read', { reason: 'key_unreadable' })
+            throw new KitFailure('needs_config', 'Credential cannot be read', {
+              reason: 'key_unreadable',
+            })
           }
           if (existing === plain) throw badRequest('apiKey', 'duplicate')
         }
@@ -317,7 +310,9 @@ export class ProviderService {
       exhaustedUntil: input.restore ? null : (old?.exhaustedUntil ?? null),
       exhaustedReason: input.restore ? null : (old?.exhaustedReason ?? null),
     }
-    endpoint.keys = old ? endpoint.keys.map((item) => (item.id === id ? key : item)) : [...endpoint.keys, key]
+    endpoint.keys = old
+      ? endpoint.keys.map((item) => (item.id === id ? key : item))
+      : [...endpoint.keys, key]
     return this.commit(actor, document, catalog)
   }
   async removeKey(actor: Actor, endpointId: string, keyId: string): Promise<Provider[]> {
@@ -325,7 +320,9 @@ export class ProviderService {
     const { endpoint } = this.endpoint(catalog, endpointId)
     if (!endpoint.keys.some((item) => item.id === keyId)) throw missing('key')
     endpoint.keys = endpoint.keys.filter((item) => item.id !== keyId)
-    catalog.secrets = catalog.secrets.filter((item) => !(item.keyId === keyId && item.endpointId === endpointId))
+    catalog.secrets = catalog.secrets.filter(
+      (item) => !(item.keyId === keyId && item.endpointId === endpointId),
+    )
     return this.commit(actor, document, catalog)
   }
   async revealKey(actor: Actor, keyId: string): Promise<string> {
@@ -335,7 +332,9 @@ export class ProviderService {
     try {
       return await this.open(actor, secret)
     } catch {
-      throw new KitFailure('needs_config', 'Credential cannot be read', { reason: 'key_unreadable' })
+      throw new KitFailure('needs_config', 'Credential cannot be read', {
+        reason: 'key_unreadable',
+      })
     }
   }
   private async snapshotFrom(
@@ -346,16 +345,25 @@ export class ProviderService {
   ): Promise<EndpointSnapshot> {
     const { endpoint } = this.endpoint(catalog, endpointId)
     const chosen =
-      keyId === undefined ? endpoint.keys.filter((key) => key.enabled) : endpoint.keys.filter((key) => key.id === keyId)
+      keyId === undefined
+        ? endpoint.keys.filter((key) => key.enabled)
+        : endpoint.keys.filter((key) => key.id === keyId)
     if (keyId !== undefined && !chosen.length) throw missing('key')
     const keys: string[] = []
     for (const key of chosen) {
-      const secret = catalog.secrets.find((item) => item.keyId === key.id && item.endpointId === endpoint.id)
-      if (!secret) throw new KitFailure('needs_config', 'Credential cannot be read', { reason: 'key_unreadable' })
+      const secret = catalog.secrets.find(
+        (item) => item.keyId === key.id && item.endpointId === endpoint.id,
+      )
+      if (!secret)
+        throw new KitFailure('needs_config', 'Credential cannot be read', {
+          reason: 'key_unreadable',
+        })
       try {
         keys.push(await this.open(actor, secret))
       } catch {
-        throw new KitFailure('needs_config', 'Credential cannot be read', { reason: 'key_unreadable' })
+        throw new KitFailure('needs_config', 'Credential cannot be read', {
+          reason: 'key_unreadable',
+        })
       }
     }
     if (keyId === undefined && keys.length) {
@@ -381,12 +389,14 @@ export class ProviderService {
   async resolve(actor: Actor, reference: ModelRef, requiredType?: ModelType): Promise<Connection> {
     const { catalog } = await this.load(actor)
     const provider = catalog.providers.find(
-      (item) => item.enabled && item.endpoints.some((endpoint) => endpoint.id === reference.endpointId),
+      (item) =>
+        item.enabled && item.endpoints.some((endpoint) => endpoint.id === reference.endpointId),
     )
     const endpoint = provider?.endpoints.find((item) => item.id === reference.endpointId)
     const model = endpoint?.models.find((item) => item.id === reference.modelId)
     if (!endpoint || !model) throw missing('model')
-    if (requiredType !== undefined && model.modelType !== requiredType) throw badRequest('model', 'unsupported_type')
+    if (requiredType !== undefined && model.modelType !== requiredType)
+      throw badRequest('model', 'unsupported_type')
     prepare({
       endpoint: {
         endpointId: endpoint.id,
@@ -403,35 +413,14 @@ export class ProviderService {
   }
   async modelOptions(actor: Actor, filter: ModelFilter = {}): Promise<ModelOption[]> {
     const { catalog } = await this.load(actor)
-    return catalog.providers
-      .filter((provider) => provider.enabled)
-      .flatMap((provider) =>
-        provider.endpoints.flatMap((endpoint) =>
-          endpoint.models
-            .filter(
-              (model) =>
-                (filter.modelType === undefined || model.modelType === filter.modelType) &&
-                (filter.supportsTools === undefined || model.supportsTools === filter.supportsTools),
-            )
-            .map((model) => ({
-              endpointId: endpoint.id,
-              modelId: model.id,
-              label: `${provider.name} · ${endpoint.slug} · ${model.id}`,
-              name: model.name,
-              modelType: model.modelType,
-              supportsTools: model.supportsTools,
-              reasoning: model.reasoning,
-              nativeWebSearch: model.nativeWebSearch,
-              canVision: model.canVision,
-            })),
-        ),
-      )
+    return modelOptions(catalog, filter)
   }
   async probe(actor: Actor, target: ProbeTarget, signal: AbortSignal): Promise<ProbeResult> {
     if (!isContract('ProbeTarget', target)) throw badRequest('target', 'invalid')
     const { catalog } = await this.load(actor)
     let endpoint: EndpointSnapshot
-    if (target.kind === 'saved') endpoint = await this.snapshotFrom(actor, catalog, target.endpointId)
+    if (target.kind === 'saved')
+      endpoint = await this.snapshotFrom(actor, catalog, target.endpointId)
     else {
       if (target.keyId !== undefined && target.endpointId === undefined) throw missing('key')
       endpoint = target.endpointId
@@ -440,66 +429,17 @@ export class ProviderService {
             baseUrl: target.baseUrl,
             protocol: target.protocol,
           }
-        : { endpointId: null, baseUrl: target.baseUrl, protocol: target.protocol, keys: [], headers: {} }
+        : {
+            endpointId: null,
+            baseUrl: target.baseUrl,
+            protocol: target.protocol,
+            keys: [],
+            headers: {},
+          }
     }
     return probeEndpoint(this.options.outbound, { endpoint, signal })
   }
   async handle(request: Request, context: WorkerContext): 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 this.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 this.save(actor, value))
-    }
-    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 this.modelOptions(actor, value))
-    }
-    if (path === `${root}/probe` && request.method === 'POST') {
-      const value: unknown = await request.json()
-      if (!isContract('ProbeTarget', value)) throw badRequest('target', 'invalid')
-      return json(await this.probe(actor, value, 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 this.saveKey(actor, value))
-    }
-    const reveal = path.match(/^\/api\/v1\/providers\/keys\/([^/]+)\/reveal$/)
-    if (reveal && request.method === 'POST') {
-      await this.options.authorizeReveal(request, context)
-      return json(await this.revealKey(actor, decodeURIComponent(reveal[1] ?? '')))
-    }
-    const key = path.match(/^\/api\/v1\/providers\/([^/]+)\/keys\/([^/]+)$/)
-    if (key && request.method === 'DELETE')
-      return json(await this.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 this.setEnabled(actor, decodeURIComponent(enabled[1] ?? ''), value.enabled))
-    }
-    const provider = path.match(/^\/api\/v1\/providers\/([^/]+)$/)
-    if (provider && request.method === 'DELETE')
-      return json(await this.remove(actor, decodeURIComponent(provider[1] ?? '')))
-    throw missing('route')
+    return handleProviderRequest(this, request, context, this.options.authorizeReveal)
   }
 }

package/src/providers/model-options.ts

@@ -0,0 +1,28 @@
+import { type ModelFilter, type ModelOption } from '@ouraihub/aether-contracts'
+import type { Catalog } from './catalog.js'
+
+export function modelOptions(catalog: Catalog, filter: ModelFilter): ModelOption[] {
+  return catalog.providers
+    .filter((provider) => provider.enabled)
+    .flatMap((provider) =>
+      provider.endpoints.flatMap((endpoint) =>
+        endpoint.models
+          .filter(
+            (model) =>
+              (filter.modelType === undefined || model.modelType === filter.modelType) &&
+              (filter.supportsTools === undefined || model.supportsTools === filter.supportsTools),
+          )
+          .map((model) => ({
+            endpointId: endpoint.id,
+            modelId: model.id,
+            label: `${provider.name} · ${endpoint.slug} · ${model.id}`,
+            name: model.name,
+            modelType: model.modelType,
+            supportsTools: model.supportsTools,
+            reasoning: model.reasoning,
+            nativeWebSearch: model.nativeWebSearch,
+            canVision: model.canVision,
+          })),
+      ),
+    )
+}

package/src/runtime-input.ts

@@ -0,0 +1,44 @@
+import type { EndStatus, KitError } from '@ouraihub/aether-contracts'
+import { safeError } from '@ouraihub/aether-core/error'
+import { charCount } from '@ouraihub/aether-core/guard'
+import { renderSystem, validate } from '@ouraihub/aether-core/engine'
+import { trimHistory } from '@ouraihub/aether-core/history'
+import type { HistoryTurn, RunInput, RunSummary } from '@ouraihub/aether-core/types'
+
+export const emptySummary = (status: EndStatus, error?: KitError): RunSummary => ({
+  status,
+  messages: [],
+  usage: {
+    inputTokens: null,
+    outputTokens: null,
+    cacheReadTokens: null,
+    cacheWriteTokens: null,
+    reasoningTokens: null,
+  },
+  cost: null,
+  contextUsage: null,
+  exhausted: false,
+  ...(error ? { error } : {}),
+})
+
+/** Final snapshots never copy arbitrary host/upstream exception text or details. */
+export const publicError = (error: unknown): KitError => ({
+  code: safeError(error).code,
+  message: 'Run could not be completed',
+})
+
+export function assemble(input: RunInput, history: readonly HistoryTurn[]): RunInput {
+  const checked = validate({ ...input, history: [] })
+  const systemChars = charCount(renderSystem(checked.system, checked.permissionMode === 'plan'))
+  const available =
+    checked.budget.contextWindow -
+    checked.budget.maxOutput -
+    Math.ceil((systemChars + charCount(checked.input)) / 3)
+  return {
+    ...checked,
+    history:
+      checked.purpose === 'writing'
+        ? []
+        : trimHistory(history, available, checked.connection.canVision),
+  }
+}