@softize/opus 25.1.0 → 25.2.0

package/src/core/assistant.ts

@@ -0,0 +1,545 @@
+/**
+ * O assistente do recurso declarado na action de leitura (ADR 0053): a validação da declaração e a
+ * projeção limitada do dado do recurso que o host entrega ao modelo.
+ *
+ * Tudo aqui é puro e sem dependência externa. O runtime usa estas funções no registro e em
+ * `readResource`; um host que recebe a saída da action por outro canal, como o MCP, aplica a mesma
+ * projeção com `projectAssistantContext`.
+ */
+
+import { error } from './errors.ts'
+import type { ActionAssistant, ActionDef, ActionError, ResultMeta } from './types.ts'
+
+/** Teto padrão, em caracteres, do JSON de `context`. */
+export const ASSISTANT_CONTEXT_DEFAULT_CHARS = 4_000
+/** Menor teto aceito em `maxContextChars`. */
+export const ASSISTANT_CONTEXT_MIN_CHARS = 1_000
+/** Maior teto aceito em `maxContextChars`. */
+export const ASSISTANT_CONTEXT_MAX_CHARS = 16_000
+/** Tamanho máximo do título do recurso, `…` incluído. Fica fora da conta do teto. */
+export const ASSISTANT_TITLE_MAX_CHARS = 200
+/** Um texto é encurtado pela metade até este mínimo, `…` incluído. */
+export const ASSISTANT_TEXT_MIN_CHARS = 200
+
+const RESOURCE_RE = /^[a-z][a-zA-Z0-9]*$/
+const SKILL_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/
+const ELLIPSIS = '…'
+
+/**
+ * Um corte ou uma ausência na projeção. `path` é o caminho na saída, sem índice de lista. Para
+ * `removed` e `missing`, é o caminho declarado (ou o título); para `items` e `shortened`, pode
+ * ficar abaixo do declarado quando o caminho declarado termina num objeto ou numa lista.
+ *
+ * - `items`: itens removidos do fim da lista em `path`; `count` diz quantos.
+ * - `shortened`: um texto em `path` foi encurtado, com `…` no fim.
+ * - `removed`: o campo declarado em `path` saiu inteiro.
+ * - `missing`: o caminho declarado não existe na saída desta execução; no título, também quando o
+ *   valor não é texto nem número.
+ */
+export interface AssistantOmission {
+  path: string
+  reason: 'items' | 'shortened' | 'removed' | 'missing'
+  count?: number
+}
+
+/** O resultado de `projectAssistantContext`. */
+export interface AssistantProjection {
+  /** O título do recurso, com no máximo 200 caracteres; `null` quando a saída não o traz. */
+  title: string | null
+  /** Somente os caminhos declarados em `context`, com a mesma estrutura da saída. */
+  data: Record<string, unknown>
+  /** `true` quando o teto obrigou a cortar `data`. */
+  truncated: boolean
+  /** O que saiu ou faltou, na ordem em que aconteceu. */
+  omitted: AssistantOmission[]
+}
+
+/** A declaração pública do assistente, com o teto resolvido. É o que o manifest, as ferramentas de
+ *  IA e o MCP projetam. */
+export interface AssistantDeclaration {
+  resource: string
+  skill: string
+  label: string
+  title: string
+  context: string[]
+  maxContextChars: number
+}
+
+/** Uma declaração registrada no runtime, com a action dona. */
+export interface RegisteredAssistant extends AssistantDeclaration {
+  /** O nome da action dona. */
+  action: string
+  /** Repete a declaração `personalData` da action dona. */
+  personalData: boolean
+}
+
+/** O teto declarado ou o padrão. */
+export function resolveAssistantContextLimit(assistant: Pick<ActionAssistant, 'maxContextChars'>): number {
+  return assistant.maxContextChars ?? ASSISTANT_CONTEXT_DEFAULT_CHARS
+}
+
+/** A declaração pública, sem referência compartilhada com o contrato. */
+export function publicAssistant(assistant: ActionAssistant): AssistantDeclaration {
+  return {
+    resource: assistant.resource,
+    skill: assistant.skill,
+    label: assistant.label,
+    title: assistant.title,
+    context: [...assistant.context],
+    maxContextChars: resolveAssistantContextLimit(assistant),
+  }
+}
+
+// Segmentos que mexem no protótipo de um objeto JavaScript não são campos de saída.
+const RESERVED_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
+
+function isValidPath(path: unknown): path is string {
+  return (
+    typeof path === 'string' &&
+    path.split('.').every((segment) => segment.length > 0 && !/\s/.test(segment) && !RESERVED_SEGMENTS.has(segment))
+  )
+}
+
+function aiEnabled(ai: ActionDef['ai']): boolean {
+  if (ai === undefined || ai === false) return false
+  if (ai === true) return true
+  return ai.enabled !== false
+}
+
+/**
+ * Confere a declaração de uma action no registro. Lança `runtime.assistant_declaration_invalid`
+ * para a forma e `runtime.assistant_context_limit_invalid` para o teto fora do intervalo. A entrada
+ * com `id` como único campo obrigatório é conferida pelo `opus gen`, que enxerga o JSON Schema.
+ */
+export function assertAssistantDeclaration(action: ActionDef): void {
+  const declared = (action as { assistant?: unknown }).assistant
+  if (declared === undefined) return
+  const problems: string[] = []
+  if (action.kind !== 'view') problems.push(`só uma action view declara assistente, e esta é ${action.kind}`)
+  if (declared === null || typeof declared !== 'object' || Array.isArray(declared)) {
+    problems.push('assistant precisa ser um objeto')
+  } else {
+    const assistant = declared as Partial<Record<keyof ActionAssistant, unknown>>
+    if (!aiEnabled(action.ai)) problems.push('a action precisa estar publicada para a IA (ai habilitado)')
+    if (typeof action.personalData !== 'boolean') problems.push('a action precisa declarar personalData, true ou false')
+    if (typeof assistant.resource !== 'string' || !RESOURCE_RE.test(assistant.resource))
+      problems.push('resource precisa ser um identificador em camelCase, como customer')
+    if (typeof assistant.skill !== 'string' || !SKILL_RE.test(assistant.skill))
+      problems.push('skill precisa estar em minúsculas com hífen, como review-customer')
+    if (typeof assistant.label !== 'string' || assistant.label.trim().length === 0)
+      problems.push('label precisa ser um texto não vazio')
+    if (!isValidPath(assistant.title)) problems.push('title precisa ser um caminho da saída, como name')
+    if (!Array.isArray(assistant.context) || !assistant.context.every(isValidPath))
+      problems.push(
+        'context precisa ser uma lista de caminhos da saída, como leads.totalCount, sem __proto__, constructor nem prototype',
+      )
+  }
+  if (problems.length > 0) {
+    throw error({
+      code: 'runtime.assistant_declaration_invalid',
+      category: 'internal',
+      message: `O assistente da action "${action.name}" é inválido: ${problems.join('; ')} (ADR 0053).`,
+    })
+  }
+  assertContextLimit(action.name, (declared as ActionAssistant).maxContextChars)
+}
+
+function assertContextLimit(owner: string, limit: unknown): void {
+  if (limit === undefined) return
+  if (
+    typeof limit === 'number' &&
+    Number.isInteger(limit) &&
+    limit >= ASSISTANT_CONTEXT_MIN_CHARS &&
+    limit <= ASSISTANT_CONTEXT_MAX_CHARS
+  )
+    return
+  throw error({
+    code: 'runtime.assistant_context_limit_invalid',
+    category: 'internal',
+    message:
+      `O maxContextChars do assistente de "${owner}" precisa ser um inteiro de ` +
+      `${ASSISTANT_CONTEXT_MIN_CHARS} a ${ASSISTANT_CONTEXT_MAX_CHARS} (ADR 0053).`,
+  })
+}
+
+// =============================================================================
+// Projeção
+// =============================================================================
+
+type Json = null | boolean | number | string | Json[] | { [key: string]: Json }
+type JsonObject = { [key: string]: Json }
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/** Grava como propriedade própria, inclusive `__proto__`, que uma atribuição trataria como protótipo. */
+function setOwn(target: JsonObject, key: string, value: Json): void {
+  Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true })
+}
+
+/** A saída como o transporte a veria: datas viram texto e `undefined` some. */
+function toJson(value: unknown): Json | undefined {
+  if (value === undefined) return undefined
+  const text = JSON.stringify(value)
+  return text === undefined ? undefined : (JSON.parse(text) as Json)
+}
+
+function size(value: Json): number {
+  return JSON.stringify(value).length
+}
+
+/** Corta um texto em `max` caracteres com `…` no fim, sem partir um par substituto. */
+function shorten(text: string, max: number): string {
+  let end = max - ELLIPSIS.length
+  const code = text.charCodeAt(end - 1)
+  if (code >= 0xd800 && code <= 0xdbff) end -= 1
+  return `${text.slice(0, end)}${ELLIPSIS}`
+}
+
+/** Remove caminhos repetidos e os cobertos por outro declarado, que já leva o valor inteiro. */
+function normalizePaths(paths: readonly string[]): string[] {
+  const unique = [...new Set(paths)]
+  return unique.filter(
+    (path) => !unique.some((other) => other !== path && path.startsWith(`${other}.`)),
+  )
+}
+
+class Omissions {
+  readonly list: AssistantOmission[] = []
+  private readonly byKey = new Map<string, AssistantOmission>()
+
+  add(path: string, reason: AssistantOmission['reason']): AssistantOmission {
+    const key = `${reason}\u0000${path}`
+    const found = this.byKey.get(key)
+    if (found !== undefined) return found
+    const entry: AssistantOmission = { path, reason }
+    this.byKey.set(key, entry)
+    this.list.push(entry)
+    return entry
+  }
+
+  removedItems(path: string, count: number): void {
+    const entry = this.add(path, 'items')
+    entry.count = (entry.count ?? 0) + count
+  }
+}
+
+const join = (prefix: string, key: string): string => (prefix === '' ? key : `${prefix}.${key}`)
+
+/** Copia de `node` somente os caminhos (relativos) em `paths`. `undefined` = nada a levar. */
+function pick(node: Json, paths: string[][], prefix: string, omitted: Omissions): Json | undefined {
+  if (paths.some((path) => path.length === 0)) return node
+  if (node === null) return null
+  if (Array.isArray(node)) {
+    const items: Json[] = []
+    for (const item of node) {
+      const picked = pick(item, paths, prefix, omitted)
+      if (picked !== undefined) items.push(picked)
+    }
+    return items
+  }
+  if (!isObject(node)) {
+    for (const path of paths) omitted.add(join(prefix, path.join('.')), 'missing')
+    return undefined
+  }
+  const groups = new Map<string, string[][]>()
+  for (const [key, ...rest] of paths) {
+    const group = groups.get(key!) ?? []
+    group.push(rest)
+    groups.set(key!, group)
+  }
+  const out: JsonObject = {}
+  for (const [key, rests] of groups) {
+    const full = join(prefix, key)
+    if (!Object.hasOwn(node, key)) {
+      for (const rest of rests) omitted.add(rest.length === 0 ? full : join(full, rest.join('.')), 'missing')
+      continue
+    }
+    const picked = pick(node[key]!, rests, full, omitted)
+    if (picked !== undefined) setOwn(out, key, picked)
+  }
+  return out
+}
+
+/**
+ * Fila de prioridade mínima por `before`: as etapas de corte escolhem o maior candidato sem varrer
+ * a projeção inteira a cada passo, o que deixaria o corte quadrático em listas longas.
+ */
+class Heap<T> {
+  private readonly items: T[] = []
+  private readonly before: (a: T, b: T) => boolean
+
+  constructor(before: (a: T, b: T) => boolean) {
+    this.before = before
+  }
+
+  push(item: T): void {
+    const items = this.items
+    items.push(item)
+    let index = items.length - 1
+    while (index > 0) {
+      const parent = (index - 1) >> 1
+      if (!this.before(items[index]!, items[parent]!)) break
+      ;[items[index], items[parent]] = [items[parent]!, items[index]!]
+      index = parent
+    }
+  }
+
+  pop(): T | undefined {
+    const items = this.items
+    const top = items[0]
+    const last = items.pop()
+    if (items.length > 0 && last !== undefined) {
+      items[0] = last
+      let index = 0
+      for (;;) {
+        const left = index * 2 + 1
+        const right = left + 1
+        let best = index
+        if (left < items.length && this.before(items[left]!, items[best]!)) best = left
+        if (right < items.length && this.before(items[right]!, items[best]!)) best = right
+        if (best === index) break
+        ;[items[index], items[best]] = [items[best]!, items[index]!]
+        index = best
+      }
+    }
+    return top
+  }
+}
+
+interface ListRef {
+  list: Json[]
+  /** Caminho na saída, sem índice de lista. */
+  path: string
+  /** Ordem na projeção: no empate, a lista que aparece primeiro perde o item. */
+  order: number
+}
+
+function collectLists(node: Json, path: string, out: ListRef[]): void {
+  if (Array.isArray(node)) {
+    out.push({ list: node, path, order: out.length })
+    for (const item of node) collectLists(item, path, out)
+  } else if (isObject(node)) {
+    for (const [key, value] of Object.entries(node)) collectLists(value, join(path, key), out)
+  }
+}
+
+function collectNestedLists(node: Json, into: WeakSet<Json[]>): void {
+  if (Array.isArray(node)) {
+    into.add(node)
+    for (const item of node) collectNestedLists(item, into)
+  } else if (isObject(node)) {
+    for (const value of Object.values(node)) collectNestedLists(value, into)
+  }
+}
+
+interface TextRef {
+  parent: JsonObject | Json[]
+  key: string | number
+  /** Caminho na saída, sem índice de lista. */
+  path: string
+  order: number
+}
+
+function collectTexts(node: Json, path: string, out: TextRef[]): void {
+  const visit = (parent: JsonObject | Json[], key: string | number, value: Json, at: string): void => {
+    if (typeof value === 'string') {
+      if (value.length > ASSISTANT_TEXT_MIN_CHARS) out.push({ parent, key, path: at, order: out.length })
+    } else if (Array.isArray(value)) {
+      value.forEach((item, index) => visit(value, index, item, at))
+    } else if (isObject(value)) {
+      for (const [childKey, child] of Object.entries(value)) visit(value, childKey, child, join(at, childKey))
+    }
+  }
+  if (isObject(node)) for (const [key, value] of Object.entries(node)) visit(node, key, value, join(path, key))
+}
+
+const textAt = (ref: TextRef): string => (ref.parent as Record<string | number, Json>)[ref.key] as string
+
+/** Tira de `node` o caminho `segments`, preservando o que outro caminho restante ainda usa. */
+function removePath(node: Json, segments: string[], depth: number, prefix: string, keep: Set<string>): boolean {
+  if (Array.isArray(node)) {
+    let removed = false
+    for (const item of node) removed = removePath(item, segments, depth, prefix, keep) || removed
+    return removed
+  }
+  if (!isObject(node)) return false
+  const key = segments[depth]!
+  if (!Object.hasOwn(node, key)) return false
+  const full = join(prefix, key)
+  if (!keep.has(full)) {
+    delete node[key]
+    return true
+  }
+  return removePath(node[key]!, segments, depth + 1, full, keep)
+}
+
+function prefixesOf(paths: string[]): Set<string> {
+  const out = new Set<string>()
+  for (const path of paths) {
+    const segments = path.split('.')
+    for (let index = 1; index <= segments.length; index += 1) out.add(segments.slice(0, index).join('.'))
+  }
+  return out
+}
+
+/**
+ * O título do recurso: o texto, ou o número como texto, no caminho de `title`, encurtado a 200
+ * caracteres. Ausente, nulo ou de outro tipo vira `null` e entra em `omitted` como `missing`, porque
+ * o recurso fica sem nome para pessoas e para o modelo. Lê a saída sem serializá-la inteira, mas
+ * aplica `toJSON` no caminho, como a serialização faria.
+ */
+export function resolveAssistantTitle(
+  assistant: Pick<ActionAssistant, 'title'>,
+  output: unknown,
+): { title: string | null; omitted: AssistantOmission[] } {
+  // Aplica `toJSON` como o JSON faria, para o título sair igual com e sem a projeção: uma data, por
+  // exemplo, vira o texto ISO nos dois caminhos.
+  const asJson = (value: unknown, key: string): unknown =>
+    typeof value === 'object' && value !== null && typeof (value as { toJSON?: unknown }).toJSON === 'function'
+      ? (value as { toJSON: (key: string) => unknown }).toJSON(key)
+      : value
+  let node: unknown = asJson(output, '')
+  for (const segment of assistant.title.split('.')) {
+    if (typeof node !== 'object' || node === null || Array.isArray(node) || !Object.hasOwn(node, segment)) {
+      node = undefined
+      break
+    }
+    node = asJson((node as Record<string, unknown>)[segment], segment)
+  }
+  const text = typeof node === 'string' ? node : typeof node === 'number' && Number.isFinite(node) ? String(node) : null
+  if (text === null) return { title: null, omitted: [{ path: assistant.title, reason: 'missing' }] }
+  if (text.length <= ASSISTANT_TITLE_MAX_CHARS) return { title: text, omitted: [] }
+  return { title: shorten(text, ASSISTANT_TITLE_MAX_CHARS), omitted: [{ path: assistant.title, reason: 'shortened' }] }
+}
+
+/**
+ * Projeta a saída da action dona no dado que o host entrega ao modelo (ADR 0053, seção 3).
+ *
+ * `data` leva só os caminhos de `context`. Um intermediário `null` vira `null` naquele ponto; um
+ * caminho ausente na saída é omitido e registrado com o motivo `missing`, sem falhar. Acima do
+ * teto, a projeção corta por etapas até caber: remove o último item da maior lista; com as listas
+ * vazias, encurta pela metade o texto mais longo, até 200 caracteres; e, por fim, remove campos
+ * inteiros, do último declarado para o primeiro. Cada etapa tira alguma coisa e a última chega a um
+ * objeto vazio, então o corte sempre termina; as duas primeiras escolhem o candidato por fila de
+ * prioridade, e o custo cresce com o tamanho da saída, não com o quadrado dele. O título fica fora
+ * do teto e é encurtado a 200 caracteres.
+ *
+ * Em `omitted`, o caminho é o da saída, sem índice de lista: para um caminho declarado que termina
+ * num objeto ou numa lista, a lista cortada ou o texto encurtado podem estar abaixo dele.
+ *
+ * Função pura: não altera a saída recebida nem registra log. Quem a chama decide o aviso sobre o que
+ * faltou. Lança se a saída não puder ser serializada em JSON (`BigInt`, referência circular).
+ */
+export function projectAssistantContext(assistant: ActionAssistant, output: unknown): AssistantProjection {
+  assertContextLimit(assistant.resource, assistant.maxContextChars)
+  const limit = resolveAssistantContextLimit(assistant)
+  const omitted = new Omissions()
+  const json = toJson(output)
+  const resolved = resolveAssistantTitle(assistant, json)
+  for (const entry of resolved.omitted) omitted.add(entry.path, entry.reason)
+  const paths = normalizePaths(assistant.context)
+
+  let data: JsonObject = {}
+  if (isObject(json)) {
+    const picked = pick(json, paths.map((path) => path.split('.')), '', omitted)
+    if (isObject(picked)) data = picked
+  } else {
+    for (const path of paths) omitted.add(path, 'missing')
+  }
+
+  let current = size(data)
+  if (current <= limit) return { title: resolved.title, data, truncated: false, omitted: omitted.list }
+
+  // 1. O último item da lista com mais itens, até as listas esvaziarem.
+  const lists: ListRef[] = []
+  collectLists(data, '', lists)
+  const detached = new WeakSet<Json[]>()
+  type ListEntry = { ref: ListRef; length: number }
+  const byLength = new Heap<ListEntry>((a, b) =>
+    a.length !== b.length ? a.length > b.length : a.ref.order < b.ref.order,
+  )
+  for (const ref of lists) if (ref.list.length > 0) byLength.push({ ref, length: ref.list.length })
+  while (current > limit) {
+    const entry = byLength.pop()
+    if (entry === undefined) break
+    const { ref } = entry
+    // Entrada vencida: a lista mudou de tamanho depois de entrar na fila, ou saiu junto com o item
+    // de outra lista.
+    if (detached.has(ref.list) || ref.list.length !== entry.length || entry.length === 0) continue
+    const item = ref.list.pop()!
+    current -= size(item) + (ref.list.length > 0 ? 1 : 0)
+    collectNestedLists(item, detached)
+    omitted.removedItems(ref.path, 1)
+    if (ref.list.length > 0) byLength.push({ ref, length: ref.list.length })
+  }
+
+  // 2. O texto mais longo pela metade, até o mínimo. Com as listas vazias, os textos que restam
+  // estão em objetos e não mudam de lugar.
+  const texts: TextRef[] = []
+  if (current > limit) collectTexts(data, '', texts)
+  type TextEntry = { ref: TextRef; length: number }
+  const byText = new Heap<TextEntry>((a, b) =>
+    a.length !== b.length ? a.length > b.length : a.ref.order < b.ref.order,
+  )
+  for (const ref of texts) byText.push({ ref, length: textAt(ref).length })
+  while (current > limit) {
+    const entry = byText.pop()
+    if (entry === undefined) break
+    const text = textAt(entry.ref)
+    const shorter = shorten(text, Math.max(ASSISTANT_TEXT_MIN_CHARS, Math.floor(text.length / 2)))
+    current -= size(text) - size(shorter)
+    ;(entry.ref.parent as Record<string | number, Json>)[entry.ref.key] = shorter
+    omitted.add(entry.ref.path, 'shortened')
+    if (shorter.length > ASSISTANT_TEXT_MIN_CHARS) byText.push({ ref: entry.ref, length: shorter.length })
+  }
+
+  // 3. Campos inteiros, do último declarado para o primeiro.
+  for (let index = paths.length - 1; index >= 0 && current > limit; index -= 1) {
+    const path = paths[index]!
+    if (removePath(data, path.split('.'), 0, '', prefixesOf(paths.slice(0, index)))) {
+      omitted.add(path, 'removed')
+      current = size(data)
+    }
+  }
+
+  return { title: resolved.title, data, truncated: true, omitted: omitted.list }
+}
+
+// =============================================================================
+// Leitura do recurso
+// =============================================================================
+
+/** O recurso lido pela action dona, como o host o mostra e o entrega ao modelo. */
+export interface ResourceDescriptor {
+  /** O tipo de recurso (`assistant.resource`). */
+  kind: string
+  id: string
+  /** O valor do campo declarado em `assistant.title`, encurtado a 200 caracteres. */
+  title: string | null
+  /** O nome do assistente para pessoas. */
+  label: string
+  /** A chave do procedimento que a IA segue. */
+  skill: string
+}
+
+/** O dado do recurso que o host pode entregar ao modelo, já limitado pelo teto. */
+export interface ResourceContext {
+  data: Record<string, unknown>
+  truncated: boolean
+  omitted: AssistantOmission[]
+  /** Repete a declaração da action dona, para o host marcar a conversa. */
+  personalData: boolean
+}
+
+/** Opções de `runtime.readResource`. */
+export interface ReadResourceOptions {
+  /** Inclui a projeção `context`. Sem isto, a leitura devolve só o descritor. */
+  context?: boolean
+}
+
+/** O resultado de `runtime.readResource`: o descritor ou o erro da action dona. */
+export type ResourceReadResult =
+  | { ok: true; resource: ResourceDescriptor; context?: ResourceContext; meta: ResultMeta }
+  | { ok: false; error: ActionError; meta?: ResultMeta }

package/src/core/index.ts

@@ -53,6 +53,7 @@ export type {
   ConfirmSpec,
   RateLimitSpec,
   AIConfig,
+  ActionAssistant,
   Example,
   ActionMessages,
   OptionsSpec,
@@ -241,3 +242,25 @@ export type {
   ResolvedRuntimeConfig,
 } from './runtime.ts'
 export { countReturnedRecords, hasInvalidEffect, resolveActionEffect } from './action-nature.ts'
+
+// — Assistente do recurso (ADR 0053) ————————————————————————————————————————————
+export {
+  ASSISTANT_CONTEXT_DEFAULT_CHARS,
+  ASSISTANT_CONTEXT_MAX_CHARS,
+  ASSISTANT_CONTEXT_MIN_CHARS,
+  ASSISTANT_TEXT_MIN_CHARS,
+  ASSISTANT_TITLE_MAX_CHARS,
+  projectAssistantContext,
+  publicAssistant,
+  resolveAssistantTitle,
+} from './assistant.ts'
+export type {
+  AssistantDeclaration,
+  AssistantOmission,
+  AssistantProjection,
+  ReadResourceOptions,
+  RegisteredAssistant,
+  ResourceContext,
+  ResourceDescriptor,
+  ResourceReadResult,
+} from './assistant.ts'