@things-factory/figure-service 10.1.167 → 10.1.169

package/server/service/figure/figure-tools-door-db.test.ts

@@ -0,0 +1,227 @@
+/**
+ * The picture a person attaches in the modeller's dock reaches the step generator, through the conversation's real
+ * door (ADR-0061, 2026-10-16 decision 2): `assistantChat` -> `registryAssistantChat` -> `proposeFigureCandidate` ->
+ * `proposeFigureSteps`.
+ *
+ * The audit found the break on this path, not in any one piece: the dock uploads files by `attachmentIds`, the door put
+ * them on the model's message only, and the tool looked for `hostContext.image`, which the dock never fills. So this
+ * runs the door itself, on sqlite, with the file stored as a conversation's attachment - the provider and the step
+ * generator are the only stand-ins.
+ *
+ * ai-assistant's door is loaded compiled (its type-graphql classes need tsc's metadata), so build it first:
+ *   yarn workspace @things-factory/ai-assistant build:server
+ */
+import type { DataSource } from 'typeorm'
+
+/* Files of a conversation are read through the storage; the database storage keeps them in the row. Set before load. */
+require('@things-factory/env').config.set('storage', { type: 'database' })
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const attachmentBase = require('@things-factory/attachment-base')
+const aiClientBase = require('@things-factory/ai-client-base')
+const aiAssistant = require('@things-factory/ai-assistant')
+
+const { __setFigureToolDepsForTest, registerFigureToolCategories } = require('./figure-tools')
+
+const PNG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+
+let dataSource: DataSource | null = null
+let DOMAIN: any
+let USER: any
+
+/** What the step generator was asked - the generator itself is figure-propose-steps' own suite. */
+const proposed: any[] = []
+/** What the conversation's model was handed, each call. */
+const modelCalls: any[][] = []
+
+beforeAll(async () => {
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...attachmentBase.entities, ...aiAssistant.entities],
+    logging: false
+  })
+  await dataSource!.initialize()
+  /* The door reads through shell's repositories - the same data source. */
+  shell.addDataSource('default', dataSource)
+
+  aiAssistant.registerAssistantMode({
+    kind: 'figure.modeller',
+    attachments: { kinds: ['image', 'text'] },
+    systemPrompt: 'You help a person author a figure.',
+    toolCategories: ['figure-authoring']
+  })
+  /* AUTH's field table is filled when the schema is built; the proposal door is declared open here. */
+  process['PRIVILEGE_OF_FIELD']['Mutation.proposeFigure'] = null
+})
+
+afterAll(async () => {
+  shell.removeDataSource('default')
+  await dataSource?.destroy()
+  dataSource = null
+  aiAssistant.clearAssistantModes()
+  aiClientBase.setAIClientForTesting(undefined)
+})
+
+beforeEach(async () => {
+  await dataSource!.synchronize(true)
+  DOMAIN = await dataSource!.getRepository(shell.Domain).save({ name: 'door-probe', subdomain: 'door-probe' })
+  USER = await dataSource!.getRepository(authBase.User).save({ name: 'author', email: 'author@door.probe', domains: [DOMAIN] } as any)
+
+  proposed.length = 0
+  modelCalls.length = 0
+  aiClientBase.clearToolRegistry()
+  __setFigureToolDepsForTest({
+    getRepository: () => ({ findOne: async () => null, find: async () => [] }),
+    Figure: class {},
+    proposeFigureSteps: async (input: any) => {
+      proposed.push(input)
+      const model = require('@hatiolab/figure-model')
+      return { steps: [{ kind: 'rename', name: 'Mixer' }], source: model.createFigureAsset('Mixer'), score: { grade: 'B' }, cost: { triangles: 12 }, attempts: 1 }
+    }
+  })
+  registerFigureToolCategories()
+
+  /* The conversation's model asks for a new figure once, then answers. */
+  let turn = 0
+  aiClientBase.setAIClientForTesting({
+    id: 'test:door',
+    chat: async () => '',
+    generateJSON: async () => ({}),
+    listModels: async () => [],
+    chatWithTools: async (messages: any[]) => {
+      modelCalls.push(messages)
+      return turn++ === 0
+        ? { toolCalls: [{ id: 'p-1', name: 'proposeFigureCandidate', arguments: { prompt: 'make it like the picture', create: true }, type: 'tool_use' }], stopReason: 'tool_use' }
+        : { text: 'A candidate is on the card.', toolCalls: [], stopReason: 'end_turn' }
+    }
+  })
+})
+
+/** A conversation about the open figure, and a picture stored with it as the dock's upload stores it. */
+async function conversationWithPicture() {
+  const session = await dataSource!.getRepository(aiAssistant.ChatSession).save({
+    domain: DOMAIN,
+    kind: 'figure.modeller',
+    anchorType: 'figure',
+    anchorId: 'fig-1',
+    visibility: 'open',
+    creator: USER,
+    updater: USER
+  } as any)
+  /* As the database storage writes an upload: the path is `<id>.<extension>`, and a read finds the row by that id. */
+  const id = require('crypto').randomUUID()
+  const picture = await dataSource!.getRepository(attachmentBase.Attachment).save({
+    id,
+    domain: DOMAIN,
+    name: 'front.png',
+    mimetype: 'image/png',
+    encoding: '7bit',
+    category: 'chat',
+    refType: 'chat-session',
+    refBy: session.id,
+    path: `${id}.png`,
+    size: String(PNG.length),
+    contents: PNG
+  } as any)
+  return { session, picture }
+}
+
+const ask = (sessionId: string, attachmentIds: string[], hostContext: any = { figureId: 'fig-1' }) =>
+  new aiAssistant.AssistantChatResolver().assistantChat(
+    {
+      sessionId,
+      messages: [{ role: 'user', content: 'make it like this picture' }],
+      mode: { kind: 'figure.modeller', target: 'fig-1' },
+      hostContext,
+      attachmentIds
+    },
+    { state: { domain: DOMAIN, user: USER } }
+  )
+
+describe('a picture sent in the dock', () => {
+  it('★ reaches the step generator through the door - the bytes stored with the conversation', async () => {
+    const { session, picture } = await conversationWithPicture()
+
+    const answer = await ask(session.id, [picture.id])
+
+    expect(answer.proposals).toHaveLength(1)
+    expect(proposed).toHaveLength(1)
+    expect(proposed[0].images).toHaveLength(1)
+    expect(Buffer.from(proposed[0].images[0].data).equals(PNG)).toBe(true)
+    expect(proposed[0].images[0].mediaType).toBe('image/png')
+  })
+
+  it('the conversation\'s model reads the same picture on the question', async () => {
+    const { session, picture } = await conversationWithPicture()
+
+    await ask(session.id, [picture.id])
+
+    const question = modelCalls[0]!.filter((message: any) => message.role === 'user').pop()
+    const image = (question.content as any[]).find(part => part.type === 'image')
+    expect(Buffer.from(image.source.data).equals(PNG)).toBe(true)
+  })
+
+  it('★ a picture the screen put in the host context does not reach the generator - only what the door checked', async () => {
+    const { session } = await conversationWithPicture()
+
+    await ask(session.id, [], { figureId: 'fig-1', image: { data: PNG.toString('base64'), mediaType: 'image/png' } })
+
+    expect(proposed).toHaveLength(1)
+    expect(proposed[0].images).toBeUndefined()
+  })
+})
+
+/*
+  The next turn's model is told which card an outcome is about (figure audit 2026-10-16 N7). The outcome row names the
+  proposal by its key, and the model never saw the key: tool results are not in the history. So the answer that offered
+  the card carries, for the model, one line with the key and the card's title.
+*/
+describe('a card the person ran, on the next turn', () => {
+  it('★ the model reads the card by its title beside the key the outcome names', async () => {
+    const { session } = await conversationWithPicture()
+    const first = await ask(session.id, [])
+    const card = first.proposals[0]
+    await new aiAssistant.ChatSessionResolver().reportProposalOutcome(session.id, card.key, { verdict: 'refused', errorCode: 'REVISION_CONFLICT' }, {
+      state: { domain: DOMAIN, user: USER }
+    })
+
+    await ask(session.id, [])
+
+    const history = modelCalls[2]!
+    const offered = history.find((message: any) => message.role === 'assistant' && String(message.content).includes(card.key))
+    expect(offered?.content).toContain(`"${card.label}"`)
+    const outcome = history.findIndex((message: any) => typeof message.content === 'string' && message.content.includes(`proposal ${card.key}: refused`))
+    expect(outcome).toBeGreaterThan(history.indexOf(offered))
+  })
+})
+
+/*
+  A tool that fails is the tool's answer: through the real door, the turn still answers and the model reads why
+  (figure audit 2026-10-16 N1). Before, `assistantChat` rejected and the dock showed the kernel's English reasons.
+*/
+describe('a proposal that could not be made', () => {
+  it('★ the turn answers, and the model is handed the reasons', async () => {
+    __setFigureToolDepsForTest({
+      getRepository: () => ({ findOne: async () => null, find: async () => [] }),
+      Figure: class {},
+      proposeFigureSteps: async () => {
+        throw Object.assign(new Error('The figure could not be made.'), { reasons: ['ATTACH_FACE: steps[4] faces along x'] })
+      }
+    })
+    const { session } = await conversationWithPicture()
+
+    const answer = await ask(session.id, [])
+
+    expect(answer.proposals ?? []).toHaveLength(0)
+    const results = modelCalls[1]!.at(-1)!.content.filter((part: any) => part.type === 'tool_result')
+    expect(results).toHaveLength(1)
+    expect(results[0].isError).toBe(true)
+    expect(JSON.parse(results[0].content).message).toMatch(/could not be made\.\nATTACH_FACE: steps\[4\]/)
+  })
+})