@things-factory/ai-assistant 10.1.154 → 10.1.155

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.154",
+  "version": "10.1.155",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -29,16 +29,18 @@
     "@material/web": "^2.0.0",
     "@operato/graphql": "^10.0.0",
     "@operato/i18n": "^10.0.0",
+    "@operato/input": "^10.0.0",
     "@operato/layout": "^10.20.0",
     "@operato/popup": "^10.16.0",
     "@operato/shell": "^10.0.0",
     "@operato/styles": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.149",
-    "@things-factory/apptool-base": "^10.1.154",
-    "@things-factory/attachment-base": "^10.1.154",
-    "@things-factory/auth-base": "^10.1.154",
+    "@things-factory/ai-client-base": "^10.1.155",
+    "@things-factory/apptool-base": "^10.1.155",
+    "@things-factory/attachment-base": "^10.1.155",
+    "@things-factory/auth-base": "^10.1.155",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/shell": "^10.1.154",
+    "@things-factory/setting-base": "^10.1.155",
+    "@things-factory/shell": "^10.1.155",
     "dompurify": "^3.0.0",
     "exceljs": "4.2.0",
     "graphql-scalars": "^1.22.0",
@@ -52,5 +54,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "f28579aa7131cbb282eb8813f8b285d9d29bb525"
+  "gitHead": "0211c9c0764a26c10151fdc7d60094fc334905ff"
 }

package/server/service/ai-agent-resolver.ts

@@ -0,0 +1,330 @@
+/*
+ * The doors of a domain's AI agents (design/ai/agent-settings.md).
+ *
+ * The settings card reads and saves the agents of the domain it is in; the dock reads the agents a person may pick.
+ * Everything here is a thin door over ai-client-base, which owns the agents, their keys and their usage. A key never
+ * leaves the server: reads carry a hint of this domain's own key and nothing of a key from above.
+ */
+import { Arg, Ctx, Directive, Field, ID, InputType, Int, Mutation, ObjectType, Query, Resolver, UseMiddleware } from 'type-graphql'
+import '@things-factory/auth-base'
+import { SpeakRefusals } from '@things-factory/shell'
+import {
+  type AiAgentEntry,
+  capabilityOf,
+  listProviderModels,
+  readAgentUsersBelow,
+  readAiAgentDirectory,
+  saveAiAgents,
+  summarizeAiUsage
+} from '@things-factory/ai-client-base'
+
+@ObjectType({ description: 'A domain, by id and name.' })
+class AiAgentDomain {
+  @Field(() => ID, { description: 'Domain id.' })
+  id: string
+
+  @Field({ description: 'Domain name.' })
+  name: string
+}
+
+@ObjectType({ description: 'One AI agent as the settings card shows it. The key itself is never here.' })
+class AiAgentView {
+  @Field(() => ID, { description: 'Agent id.' })
+  id: string
+
+  @Field({ description: 'The name a person picks it by.' })
+  name: string
+
+  @Field({ description: 'openai, anthropic or gemini.' })
+  provider: string
+
+  @Field({ description: 'The model it answers with.' })
+  model: string
+
+  @Field({ nullable: true, description: 'A gateway or proxy the provider is reached through.' })
+  baseURL?: string
+
+  @Field({ nullable: true, description: 'OpenAI organization.' })
+  organization?: string
+
+  @Field({ description: 'Off takes it out of this domain and every domain below.' })
+  active: boolean
+
+  @Field(() => AiAgentDomain, { description: 'The domain that declared it.' })
+  owner: AiAgentDomain
+
+  @Field({ description: 'Declared by a domain above. Read-only here.' })
+  inherited: boolean
+
+  @Field({ description: 'An inherited agent this domain does not use.' })
+  turnedOff: boolean
+
+  @Field({ description: 'own, inherited, overridden or missing - where the key that answers comes from.' })
+  keyState: string
+
+  @Field(() => AiAgentDomain, { nullable: true, description: 'The domain whose key answers.' })
+  keyDomain?: AiAgentDomain
+
+  @Field({ nullable: true, description: 'A hint of this domain\'s own key, such as ••••abcd. Never given for a key from above.' })
+  keyHint?: string
+
+  @Field({ description: 'Active, used here, and has a key - a person can pick it.' })
+  usable: boolean
+
+  @Field({ description: 'The agent a person gets before picking one.' })
+  isDefault: boolean
+
+  @Field(() => [AiAgentDomain], { description: 'For this domain\'s own agents: the domains below that use it.' })
+  usedBelow: AiAgentDomain[]
+}
+
+@ObjectType({ description: 'A domain\'s AI agents and how its AI stands.' })
+class AiAgentSettings {
+  @Field(() => [AiAgentDomain], { description: 'This domain and the domains above it, closest first.' })
+  chain: AiAgentDomain[]
+
+  @Field(() => [AiAgentView], { description: 'This domain\'s agents, then each domain above\'s, closest first.' })
+  agents: AiAgentView[]
+
+  @Field({ nullable: true, description: 'The agent a person gets before picking one.' })
+  defaultAgentId?: string
+
+  @Field({ description: 'own, inherited, first or none - how the default was decided.' })
+  defaultFrom: string
+
+  @Field({ description: 'configured or not-configured.' })
+  state: string
+
+  @Field({ nullable: true, description: 'Why it is not configured: no-agent, no-agent-key or no-usable-agent.' })
+  reason?: string
+}
+
+@ObjectType({ description: 'An AI agent a person may pick in the dock.' })
+class AiAgentChoice {
+  @Field(() => ID, { description: 'Agent id - what assistantChat takes as agentId.' })
+  id: string
+
+  @Field({ description: 'The name a person picks it by.' })
+  name: string
+
+  @Field({ description: 'openai, anthropic or gemini.' })
+  provider: string
+
+  @Field({ description: 'The model it answers with.' })
+  model: string
+
+  @Field({ description: 'The agent a person gets before picking one.' })
+  isDefault: boolean
+}
+
+@InputType({ description: 'One of this domain\'s own agents as the settings card saves it.' })
+class AiAgentInput {
+  @Field(() => ID, { nullable: true, description: 'Empty for a new agent.' })
+  id?: string
+
+  @Field({ description: 'The name a person picks it by.' })
+  name: string
+
+  @Field({ description: 'openai, anthropic or gemini.' })
+  provider: string
+
+  @Field({ description: 'A model from aiProviderModels.' })
+  model: string
+
+  @Field({ nullable: true, description: 'A gateway or proxy the provider is reached through.' })
+  baseURL?: string
+
+  @Field({ nullable: true, description: 'OpenAI organization.' })
+  organization?: string
+
+  @Field({ description: 'Off takes it out of this domain and every domain below.' })
+  active: boolean
+
+  @Field({ nullable: true, description: 'A new API key. Left out, the stored key stays.' })
+  apiKey?: string
+}
+
+@InputType({ description: 'This domain\'s key for an agent it inherits.' })
+class InheritedKeyInput {
+  @Field(() => ID, { description: 'The inherited agent.' })
+  agentId: string
+
+  @Field({ nullable: true, description: 'A key of this domain to answer the agent with.' })
+  apiKey?: string
+
+  @Field({ nullable: true, description: 'Go back to the key of the domain above.' })
+  clear?: boolean
+}
+
+@InputType({ description: 'A domain\'s agents as the settings card saves them.' })
+class AiAgentsInput {
+  @Field(() => [AiAgentInput], { description: 'The whole list of this domain\'s own agents. One left out is deleted.' })
+  agents: AiAgentInput[]
+
+  @Field({ nullable: true, description: 'This domain\'s default - its own agent or an inherited one.' })
+  defaultAgentId?: string
+
+  @Field(() => [String], { nullable: true, description: 'Inherited agents this domain does not use.' })
+  turnedOff?: string[]
+
+  @Field(() => [InheritedKeyInput], { nullable: true, description: 'This domain\'s keys for inherited agents.' })
+  inheritedKeys?: InheritedKeyInput[]
+}
+
+@ObjectType({ description: 'AI usage of one bucket, agent and person.' })
+class AiUsageBucket {
+  @Field({ description: 'The hour, day or month in the domain\'s time zone.' })
+  bucket: string
+
+  @Field({ nullable: true, description: 'Agent id.' })
+  agentId?: string
+
+  @Field({ nullable: true, description: 'Agent name. Empty for a deleted agent.' })
+  agentName?: string
+
+  @Field({ description: 'openai, anthropic or gemini.' })
+  provider: string
+
+  @Field({ description: 'The model the provider reported.' })
+  model: string
+
+  @Field({ description: 'The domain the calls were made in.' })
+  domainId: string
+
+  @Field({ description: 'Its name.' })
+  domainName: string
+
+  @Field({ nullable: true, description: 'The person. Empty for a domain below and for calls with no person.' })
+  userId?: string
+
+  @Field({ nullable: true, description: 'The person\'s name.' })
+  userName?: string
+
+  @Field(() => Int, { description: 'Provider requests.' })
+  calls: number
+
+  @Field(() => Int, { description: 'Input tokens.' })
+  inputTokens: number
+
+  @Field(() => Int, { description: 'Output tokens.' })
+  outputTokens: number
+
+  @Field(() => Int, { description: 'Requests that failed.' })
+  failures: number
+}
+
+@Resolver()
+@UseMiddleware(SpeakRefusals)
+export class AiAgentResolver {
+  @Query(() => AiAgentSettings, { description: 'This domain\'s AI agents, the ones it inherits, and how its AI stands.' })
+  @Directive('@privilege(category: "setting", privilege: "query", domainOwnerGranted: true)')
+  async aiAgentSettings(@Ctx() context: ResolverContext): Promise<AiAgentSettings> {
+    const { domain } = context.state
+    const directory = await readAiAgentDirectory(domain)
+    const nameOf = new Map(directory.chain.map(one => [one.id, one.name]))
+    const ownIds = directory.entries.filter(one => !one.inherited).map(one => one.spec.id)
+    const usedBelow = await readAgentUsersBelow(domain, ownIds)
+    const capability = capabilityOf(directory)
+
+    return {
+      chain: directory.chain,
+      agents: directory.entries.map(entry => agentView(entry, directory.defaultAgentId, nameOf, usedBelow.get(entry.spec.id) ?? [])),
+      defaultAgentId: directory.defaultAgentId,
+      defaultFrom: directory.defaultFrom,
+      state: capability.state,
+      reason: capability.reason
+    }
+  }
+
+  @Query(() => [AiAgentChoice], { description: 'The AI agents a person may pick in the dock - usable ones only.' })
+  @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
+  async aiAgentChoices(@Ctx() context: ResolverContext): Promise<AiAgentChoice[]> {
+    const directory = await readAiAgentDirectory(context.state.domain)
+    return directory.entries
+      .filter(one => one.usable)
+      .map(one => ({
+        id: one.spec.id,
+        name: one.spec.name,
+        provider: one.spec.provider,
+        model: one.spec.model,
+        isDefault: one.spec.id === directory.defaultAgentId
+      }))
+  }
+
+  @Query(() => [String], {
+    description:
+      'The conversation models a provider offers to a key - a typed key, or the stored key of one of this domain\'s agents. A model is only ever picked from this list.'
+  })
+  @Directive('@privilege(category: "setting", privilege: "query", domainOwnerGranted: true)')
+  async aiProviderModels(
+    @Arg('provider') provider: string,
+    @Arg('apiKey', { nullable: true }) apiKey: string,
+    @Arg('agentId', { nullable: true }) agentId: string,
+    @Arg('baseURL', { nullable: true }) baseURL: string,
+    @Arg('organization', { nullable: true }) organization: string,
+    @Ctx() context: ResolverContext
+  ): Promise<string[]> {
+    let key = apiKey?.trim()
+    if (!key && agentId) {
+      const directory = await readAiAgentDirectory(context.state.domain)
+      key = directory.entries.find(one => one.spec.id === agentId && !one.inherited)?.apiKey
+    }
+    return listProviderModels({ provider, apiKey: key ?? '', baseURL, organization })
+  }
+
+  @Mutation(() => Boolean, {
+    description: 'Saves this domain\'s AI agents and their keys in one transaction. Read aiAgentSettings again for how they now stand.'
+  })
+  @Directive('@transaction')
+  @Directive('@privilege(category: "setting", privilege: "mutation", domainOwnerGranted: true)')
+  async saveAiAgents(@Arg('input', () => AiAgentsInput) input: AiAgentsInput, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain, user } = context.state
+    await saveAiAgents(input, { tx, domain, user })
+    return true
+  }
+
+  @Query(() => [AiUsageBucket], {
+    description:
+      'AI usage per bucket, agent and person, in this domain\'s time zone. With includeDescendants, what the domains below did with this domain\'s agents is added - per domain, without their people.'
+  })
+  @Directive('@privilege(category: "setting", privilege: "query", domainOwnerGranted: true)')
+  async aiUsageSummary(
+    @Arg('from') from: Date,
+    @Arg('to') to: Date,
+    @Arg('bucket', { defaultValue: 'day' }) bucket: string,
+    @Arg('agentIds', () => [String], { nullable: true }) agentIds: string[],
+    @Arg('userIds', () => [String], { nullable: true }) userIds: string[],
+    @Arg('includeDescendants', { nullable: true }) includeDescendants: boolean,
+    @Ctx() context: ResolverContext
+  ): Promise<AiUsageBucket[]> {
+    const size = bucket === 'hour' || bucket === 'month' ? bucket : 'day'
+    return summarizeAiUsage(context.state.domain, { from, to, bucket: size, agentIds, userIds, includeDescendants: !!includeDescendants })
+  }
+}
+
+function agentView(
+  entry: AiAgentEntry,
+  defaultAgentId: string | undefined,
+  nameOf: Map<string, string>,
+  usedBelow: { id: string; name: string }[]
+): AiAgentView {
+  const domainOf = (id?: string) => (id ? { id, name: nameOf.get(id) ?? id } : undefined)
+  return {
+    id: entry.spec.id,
+    name: entry.spec.name,
+    provider: entry.spec.provider,
+    model: entry.spec.model,
+    baseURL: entry.spec.baseURL,
+    organization: entry.spec.organization,
+    active: entry.spec.active,
+    owner: domainOf(entry.ownerDomainId)!,
+    inherited: entry.inherited,
+    turnedOff: entry.turnedOff,
+    keyState: entry.keyState,
+    keyDomain: domainOf(entry.keyDomainId),
+    keyHint: entry.keyHint,
+    usable: entry.usable,
+    isDefault: entry.spec.id === defaultAgentId,
+    usedBelow: entry.inherited ? [] : usedBelow
+  }
+}

package/server/service/assistant-capability-resolver.ts

@@ -29,18 +29,18 @@ class AiRegistrationWarning {
   message: string
 }
 
-@ObjectType({ description: "Whether this deployment has an AI, and what its registrations are missing." })
+@ObjectType({ description: "Whether this domain has an AI, and what the registrations are missing." })
 class AiCapabilityView {
   @Field({ description: "'configured' or 'not-configured'. A screen that has not asked yet knows a third state of its own: it does not know." })
   state: string
 
-  @Field({ nullable: true, description: 'Which provider answers.' })
+  @Field({ nullable: true, description: 'The provider of the domain\'s default AI agent.' })
   provider?: string
 
-  @Field({ nullable: true, description: 'The default model this deployment would use.' })
+  @Field({ nullable: true, description: 'The model of the domain\'s default AI agent.' })
   model?: string
 
-  @Field({ nullable: true, description: 'Why it is not configured: no-config · no-provider · unknown-provider · no-adapter.' })
+  @Field({ nullable: true, description: 'Why it is not configured: no-agent · no-agent-key · no-usable-agent.' })
   reason?: string
 
   @Field(() => [AiRegistrationWarning], { description: 'Tools with no declared privilege, and modes offering work their tools cannot do.' })
@@ -50,11 +50,11 @@ class AiCapabilityView {
 @Resolver()
 export class AssistantCapabilityResolver {
   @Query(() => AiCapabilityView, {
-    description: 'Whether this deployment has an AI configured, and which registrations are incomplete. Read this before offering to ask the assistant — do not find out by failing.'
+    description: 'Whether this domain has a usable AI agent, and which registrations are incomplete. Read this before offering to ask the assistant — do not find out by failing.'
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
-  async aiCapability(@Ctx() _context: any): Promise<AiCapabilityView> {
-    const capability = aiCapability()
+  async aiCapability(@Ctx() context: any): Promise<AiCapabilityView> {
+    const capability = await aiCapability(context.state.domain)
     const warnings = [...getToolRegistryWarnings(), ...getAssistantModeWarnings()].map(warning => ({
       code: warning.code,
       params: warning.params,

package/server/service/assistant-chat-resolver.ts

@@ -26,15 +26,8 @@ import { Arg, Ctx, Directive, Field, InputType, Mutation, ObjectType, Resolver }
 import { GraphQLJSON } from 'graphql-scalars'
 import '@things-factory/auth-base'
 
-import { config } from '@things-factory/env'
-import { getRepository } from '@things-factory/shell'
-import {
-  createAIClient,
-  findToolSpec,
-  getDefaultAIClient,
-  registryAssistantChat,
-  type AIClient
-} from '@things-factory/ai-client-base'
+import { getRepository, rethrowSpoken } from '@things-factory/shell'
+import { aiClientFor, findToolSpec, registryAssistantChat, type AgentClient } from '@things-factory/ai-client-base'
 
 import { ChatSession } from './chat-session/chat-session.js'
 import { assertStationSession } from './chat-session/station-session-guard.js'
@@ -132,6 +125,12 @@ class AssistantChatInput {
   })
   attachmentIds?: string[]
 
+  @Field({
+    nullable: true,
+    description:
+      'The AI agent the person picked for this turn, from aiAgentChoices. Omitted takes the domain default. An agent this domain cannot use is refused - the provider, the model and the key are always the server\'s.'
+  })
+  agentId?: string
 }
 
 @ObjectType()
@@ -142,6 +141,9 @@ class AssistantChatOutput {
   @Field({ description: 'AI client identifier (provider:model).' })
   clientId: string
 
+  @Field({ nullable: true, description: 'The AI agent that answered.' })
+  agentId?: string
+
   @Field({ nullable: true, description: 'Echo of the session id, when persisted.' })
   sessionId?: string
 
@@ -186,14 +188,6 @@ class AssistantChatOutput {
   groundingWarnings?: any
 }
 
-function resolveAIClient(): AIClient | undefined {
-  const existing = getDefaultAIClient()
-  if (existing) return existing
-  const cfg = config.get('aiClient', null) as any
-  if (cfg && cfg.provider) return createAIClient(cfg)
-  return undefined
-}
-
 @Resolver()
 export class AssistantChatResolver {
   /*
@@ -213,12 +207,26 @@ export class AssistantChatResolver {
    */
   @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
   async assistantChat(@Arg('input') input: AssistantChatInput, @Ctx() context: any): Promise<AssistantChatOutput> {
-    const client = resolveAIClient()
-    if (!client) {
-      throw new Error(
-        'No AI client configured. Set config.aiClient = { provider, model, apiKey } or call setDefaultAIClient(...).'
-      )
+    const { domain, user } = context.state
+
+    /*
+     * The domain's agent - the one picked, or the default (design/ai/agent-settings.md §4). Asked before anything is
+     * stored: a domain with no AI, or an agent it cannot use, is refused as itself.
+     */
+    let client: AgentClient
+    try {
+      client = await aiClientFor({
+        domain,
+        user,
+        agentId: input.agentId,
+        modeKind: input.mode.kind,
+        sessionId: input.sessionId
+      })
+    } catch (error) {
+      rethrowSpoken(error, context)
     }
+    /* A tool that asks a model of its own within this turn answers with the same agent (ToolCallContext.state). */
+    context.state.aiAgentId = client.agent.id
 
     /*
      * Read the declaration before anything is stored. A kind this server does not have is a
@@ -228,7 +236,6 @@ export class AssistantChatResolver {
     const t = requestTranslator(context)
     const settings = resolveModeSettings(input.mode, t)
 
-    const { domain, user } = context.state
     const sessionRepo = getRepository(ChatSession)
     const messageRepo = getRepository(ChatMessage)
 
@@ -493,7 +500,6 @@ export class AssistantChatResolver {
         hostContext: input.hostContext
       }),
       state: context.state,
-      model: settings.model,
       temperature: settings.temperature,
       maxTokens: settings.maxTokens,
       requireToolOnFirstTurn: settings.requireToolOnFirstTurn
@@ -543,6 +549,7 @@ export class AssistantChatResolver {
 
       await sessionRepo.update(session.id!, {
         aiClientId: client.id,
+        agentId: client.agent.id,
         updater: user,
         ...activityPatch(result.reply, new Date(), answerDoors)
       } as any)
@@ -568,6 +575,7 @@ export class AssistantChatResolver {
     return {
       reply: result.reply,
       clientId: client.id,
+      agentId: client.agent.id,
       sessionId: session?.id,
       userMessageId,
       assistantMessageId,

package/server/service/assistant-mode/resolve.test.ts

@@ -19,7 +19,6 @@ beforeEach(() => {
     systemPrompt: 'you answer about one space',
     toolCategories: ['twin-ops'],
     requireToolOnFirstTurn: true,
-    model: 'claude-sonnet-5',
     maxTokens: 2048,
     temperature: 0.2,
     slashTemplates: [{ name: 'summarize', descriptionKey: 'twin.slash.summarize', templateKey: 'twin.slash.summarize.template' }],
@@ -37,7 +36,6 @@ it('★ the settings come from the registered mode', () => {
     /* Every conversation may put a large result on the AI 작업판 (design/ai/workspace.md). */
     toolCategories: ['twin-ops', 'assistant-workspace'],
     requireToolOnFirstTurn: true,
-    model: 'claude-sonnet-5',
     temperature: 0.2,
     maxTokens: 2048
   })

package/server/service/assistant-mode/resolve.ts

@@ -38,7 +38,6 @@ export interface ModeSettings {
   systemPrompt: string
   toolCategories?: string[]
   requireToolOnFirstTurn?: boolean
-  model?: string
   temperature?: number
   maxTokens?: number
 }
@@ -70,7 +69,6 @@ export function resolveModeSettings(ref: AssistantModeRef, t: Translate): ModeSe
     /* A mode that takes attachments can open the files sent in earlier turns (design/ai/shared-dock.md §9-4). */
     toolCategories: modeToolCategories(mode),
     requireToolOnFirstTurn: mode.requireToolOnFirstTurn,
-    model: mode.model,
     temperature: mode.temperature,
     maxTokens: mode.maxTokens
   }

package/server/service/assistant-mode/types.ts

@@ -62,8 +62,7 @@ export interface AssistantModeSpec {
   toolCategories?: string[]
   /** Make the model read before it answers — for surfaces whose subject is live state. */
   requireToolOnFirstTurn?: boolean
-  /** Model and limits are policy, not a request field. */
-  model?: string
+  /** Limits are policy, not a request field. The model is the domain's AI agent's (design/ai/agent-settings.md). */
   temperature?: number
   maxTokens?: number
   /** What `/` offers. Declared as keys; the server translates. */

package/server/service/chat-session/chat-session.ts

@@ -206,6 +206,11 @@ export class ChatSession {
   @Field({ nullable: true })
   aiClientId?: string
 
+  /** The agent that answered the last turn. Every turn's agent is in the AI usage rows. */
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'The AI agent that answered the last turn.' })
+  agentId?: string
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/server/service/index.ts

@@ -2,6 +2,7 @@ import { ChatSessionResolver } from './chat-session-resolver.js'
 import { AssistantChatResolver } from './assistant-chat-resolver.js'
 import { AssistantModeResolver } from './assistant-mode/assistant-mode-resolver.js'
 import { AssistantCapabilityResolver } from './assistant-capability-resolver.js'
+import { AiAgentResolver } from './ai-agent-resolver.js'
 import { MySessionActivitySubscription } from './chat-session/session-activity-subscription.js'
 import { ChatMessageSubscription } from './chat-message/chat-message-subscription.js'
 import { entities as ChatSessionEntities } from './chat-session/index.js'
@@ -72,6 +73,8 @@ export const schema = {
     AssistantModeResolver,
     /* 「이 배포에 AI 가 있나 · 무엇이 선언 없이 등록됐나」 — 창구 하나(표준 A7-a). */
     AssistantCapabilityResolver,
+    /* A domain's AI agents - the settings card and the dock's picker (design/ai/agent-settings.md). */
+    AiAgentResolver,
     ChatMessageSubscription,
     /* 내가 참여한 모든 세션의 활동 — 창을 닫아 둔 표면이 배지·목록을 갱신할 수 있게. */
     MySessionActivitySubscription,

package/server/service/testing/mode-conformance.ts

@@ -48,7 +48,6 @@ export async function runRegisteredMode(
     systemPrompt: settings.systemPrompt,
     toolCategories: settings.toolCategories,
     requireToolOnFirstTurn: (requiredToolOnFirstTurn = Boolean(settings.requireToolOnFirstTurn)),
-    model: settings.model,
     temperature: settings.temperature,
     maxTokens: settings.maxTokens,
     hostContext: options.hostContext,

package/server/tool-registry-boot-report.test.ts

@@ -9,6 +9,8 @@
  */
 jest.mock('@things-factory/env', () => ({ logger: { warn: jest.fn() } }))
 jest.mock('@things-factory/auth-base', () => ({ privilegeOfField: () => ({ known: false }) }))
+/* ai-client-base keeps the AI usage table since 2026-10-12, so its root brings shell too - the same stand-in. */
+jest.mock('@things-factory/ai-client-base', () => ({ getToolRegistryWarnings: () => [] }))
 
 import { formatToolRegistryWarnings } from './tool-registry-boot-report'