@things-factory/ai-client-base 10.1.212 → 10.1.215

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-client-base",
-  "version": "10.1.212",
+  "version": "10.1.215",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -24,11 +24,11 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.40.0",
     "@google/generative-ai": "^0.24.0",
-    "@things-factory/auth-base": "^10.1.212",
+    "@things-factory/auth-base": "^10.1.215",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.212",
+    "@things-factory/setting-base": "^10.1.215",
     "@things-factory/shell": "^10.1.208",
     "openai": "^4.0.0"
   },
-  "gitHead": "1e1cdb79fca2915580429af451b6cf1dae653a93"
+  "gitHead": "7de5e80eb1f4e2e268746aee39f820e7563f454d"
 }

package/server/service/assistant/registry-assistant.ts

@@ -101,7 +101,8 @@ export interface RegistryAssistantInput {
    */
   onToolCall?: (record: ToolCallRecord) => void
   /** Set for an unattended run; tools and recorders see it as `context.run`. */
-  run?: UnattendedRunRef
+  run?: UnattendedRunRef  /** The stored conversation of this turn; tools see it as `context.conversation`. The caller's value, never the client's. */
+  conversation?: { id: string }
 }
 
 export interface RegistryAssistantResult extends AssistantChatResult<unknown> {
@@ -165,7 +166,8 @@ export async function registryAssistantChat(input: RegistryAssistantInput): Prom
     /* 번역기와 첨부는 서버의 값이다 — `host` 에서 받지 않는다(ADR-0061 2026-10-16 판정 1·2). */
     t: input.t ?? defaultValueTranslate,
     attachments: input.attachments ?? [],
-    ...(input.run ? { run: input.run } : {})
+    ...(input.run ? { run: input.run } : {}),
+    ...(input.conversation?.id ? { conversation: { id: input.conversation.id } } : {})
   }
 
   const recorded = async (run: ToolCallRun, context: ToolCallContext) => {

package/server/service/assistant/tool-budget.test.ts

@@ -154,6 +154,17 @@ describe('a scope larger than one call carries', () => {
     expect(JSON.parse(seen[1].messages.at(-1).content[0].content)).toMatchObject({ opened: ['readList150'], alreadyOffered: ['readList3'] })
   })
 
+  it('★ a wrong name among right ones opens the right ones, and says what the wrong one most likely meant', async () => {
+    const categories = registerLists(165)
+    const { client, seen } = recordingClient([reply(undefined, [TC(OPEN_TOOLS, { names: ['readList150', 'queryList151'] })]), reply(undefined, [TC(OPEN_TOOLS, { names: ['queryList151'] })]), reply('done')])
+    await registryAssistantChat(input({ client, toolCategories: categories, front: { categories: ['list-3'] } }))
+
+    expect(JSON.parse(seen[1].messages.at(-1).content[0].content)).toMatchObject({ opened: ['readList150'], notOffered: ['queryList151'], suggestions: { queryList151: ['readList151'] } })
+    expect(names(seen[1].tools)).toContain('readList150')
+    /* Only wrong names: refused, still with what each most likely meant. */
+    expect(JSON.parse(seen[2].messages.at(-1).content[0].content)).toMatchObject({ rejected: true, error: 'tool-not-offered', suggestions: { queryList151: ['readList151'] } })
+  })
+
   it('★ a tool called before it is opened does not run - the model is told to open it', async () => {
     const categories = registerLists(165)
     const { client, seen } = recordingClient([reply(undefined, [TC('readList150')]), reply('done')])

package/server/service/assistant/tool-budget.ts

@@ -120,11 +120,32 @@ export function toolOfferState(scope: ToolScope, front: ToolFront = {}) {
   const offered = new Map<string, ToolSpec>([...plan.offered, ...(opening ? [opening] : [])].map(spec => [spec.name, spec]))
   const categoryOf = new Map<string, ScopedCategory>(scope.categories.flatMap(category => category.specs.map(spec => [spec.name, category] as [string, ScopedCategory])))
 
+  /*
+   * The tools of this scope a wrong name most likely meant - the same name after its verb (`readOfficeExpenditureRequest`
+   * for `queryOfficeExpenditureRequest`). Only this scope's: a tool the person may not use is never named.
+   */
+  const meant = (name: string) => {
+    const stem = name.replace(/^[a-z]+/, '')
+    return stem ? [...openable.keys(), ...offered.keys()].filter(one => one !== name && one.replace(/^[a-z]+/, '') === stem) : []
+  }
+
+  /*
+   * A wrong name among right ones does not hold the right ones back: asked for a card, the model opened the card tool with
+   * a read it named wrong, got nothing open, and told the person the tools were not there (2026-10-25). The right ones
+   * open; each wrong one is said with what it most likely meant.
+   */
   function open(names: string[]) {
-    const unknown = names.filter(name => !openable.has(name) && !offered.has(name))
-    if (unknown.length) {
-      return { rejected: true, error: 'tool-not-offered', names: unknown, message: `these are not in the list of tools you can open: ${unknown.join(', ')}. Use the exact names from the list.` }
+    const unknown = [...new Set(names.filter(name => !openable.has(name) && !offered.has(name)))]
+    const suggestions = Object.fromEntries(unknown.map(name => [name, meant(name)]).filter(([, near]) => near.length))
+    const notInList = unknown.length
+      ? `${unknown.join(', ')} ${unknown.length > 1 ? 'are' : 'is'} not in the list of tools you can open` +
+        (Object.keys(suggestions).length ? ` - ${Object.entries(suggestions).map(([name, near]) => `for ${name} use ${(near as string[]).join(' or ')}`).join('; ')}` : '') +
+        '. Use the exact names from the list.'
+      : ''
+    if (unknown.length && unknown.length === new Set(names).size) {
+      return { rejected: true, error: 'tool-not-offered', names: unknown, ...(Object.keys(suggestions).length ? { suggestions } : {}), message: `${notInList} Call ${OPEN_TOOLS} again now.` }
     }
+    names = names.filter(name => !unknown.includes(name))
     const fresh = [...new Set(names)].filter(name => !offered.has(name))
     const already = [...new Set(names)].filter(name => offered.has(name) && name !== OPEN_TOOLS)
     const room = MAX_OFFERED_TOOLS - offered.size
@@ -138,13 +159,15 @@ export function toolOfferState(scope: ToolScope, front: ToolFront = {}) {
     }
     for (const name of fresh) offered.set(name, openable.get(name)!)
     const guidance = [...new Set(fresh.map(name => categoryOf.get(name)?.guidance).filter(Boolean))]
+    const said = already.length
+      ? `${already.join(', ')} ${already.length > 1 ? 'are' : 'is'} already open - call ${already.length > 1 ? 'them' : 'it'} now. ${fresh.length ? 'The others are open from your next step on.' : ''}`.trim()
+      : 'these tools are open from your next step on. Call them as the question needs.'
     return {
       opened: fresh,
       ...(already.length ? { alreadyOffered: already } : {}),
+      ...(unknown.length ? { notOffered: unknown, ...(Object.keys(suggestions).length ? { suggestions } : {}) } : {}),
       ...(guidance.length ? { guidance: guidance.join('\n') } : {}),
-      message: already.length
-        ? `${already.join(', ')} ${already.length > 1 ? 'are' : 'is'} already open - call ${already.length > 1 ? 'them' : 'it'} now. ${fresh.length ? 'The others are open from your next step on.' : ''}`.trim()
-        : 'these tools are open from your next step on. Call them as the question needs.'
+      message: notInList ? `${said} ${notInList} Open it now and go on.` : said
     }
   }
 

package/server/service/tool-registry/types.ts

@@ -75,6 +75,12 @@ export interface ToolCallContext {
    * it; a turn has none. The server's value - never from `host`.
    */
   run?: UnattendedRunRef
+  /**
+   * The stored conversation this turn belongs to - the server's value, never from `host`. A tool that acts on the room
+   * itself (inviting someone into it) reads it and asks the room's own rules; absent on a surface with no stored
+   * conversation and in an unattended run.
+   */
+  conversation?: { id: string }
 }
 
 export interface ToolCallMode {