@things-factory/figure-service 10.1.168 → 10.1.170

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.168",
+  "version": "10.1.170",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -25,9 +25,9 @@
     "test:templates": "node --test scripts/templates.test.mts"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.7.0",
+    "@hatiolab/figure-model": "^0.7.2",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.168",
+    "@things-factory/ai-client-base": "^10.1.170",
     "@things-factory/attachment-base": "^10.1.167",
     "@things-factory/auth-base": "^10.1.167",
     "@things-factory/env": "^10.1.149",
@@ -38,5 +38,5 @@
     "jszip": "^3.10.1",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "fe067ff11d90effffc2523374453d9b8313b489f"
+  "gitHead": "1956b73789eace6376f1d79443306e1bb8e61908"
 }

package/server/service/figure/figure-propose-steps.test.ts

@@ -6,7 +6,7 @@
  * the proposer says it could not make it, and nothing half made comes back.
  */
 import { FIGURE_PROPOSAL_GRAMMAR, addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, inspectFigureAsset, proposeFigureOccupancy } from '@hatiolab/figure-model'
-import type { AIClient } from '@things-factory/ai-client-base'
+import { AIAnswerNotJSON, type AIClient } from '@things-factory/ai-client-base'
 
 import { ProposeFigureFailure, judgeFigureAnswer, proposalFailureForPerson, proposeFigureSteps, rulesPromptFigure } from './figure-propose-steps'
 
@@ -56,6 +56,18 @@ describe('the model is told the kernel\'s commands and the open draft', () => {
     expect(ours).not.toMatch(/"parts"\s*:\s*\[|anchor/i)
   })
 
+  /*
+    :3300, 2026-10-16, a real model asked for a conveyor with 12 rollers: one answer added and fastened every roller and
+    frame rail by hand, sixty steps, and fastened a rail twice (ATTACH_REPLACED at steps[59]); another named a part it
+    had not added. Both are rules of writing, so they are taught with the rules.
+  */
+  it('teaches a row of the same part as one part repeated, and each part fastened once', () => {
+    const rules = rulesPromptFigure()
+    expect(rules).toMatch(/same part .*make-repeat/)
+    expect(rules).toMatch(/Fasten each part once/)
+    expect(rules).toMatch(/fasten only to the mounting plane or to a part an earlier step added/)
+  })
+
   it('a measure asked to be the same as another is linked, not copied (:3300, 2026-09-26: 「몸통 지름과 같게」 came as a fixed 100)', () => {
     expect(rulesPromptFigure()).toMatch(/same as, matches or follows another part or the figure, write link-dimension/)
   })
@@ -103,14 +115,52 @@ describe('the steps are held to the kernel and the gate', () => {
   })
 
   it('three refusals said back, then it says it could not make it, with the last reasons -- nothing half made', async () => {
-    const client = stubClient([{ steps: wrongFace }, new Error('cut short'), { nope: true }])
+    const client = stubClient([{ steps: wrongFace }, new AIAnswerNotJSON('no balanced JSON found'), { nope: true }])
     const failure = await proposeFigureSteps({ client, prompt: '리프트 테이블', name: 'Lift table' }).catch(e => e)
     expect(failure).toBeInstanceOf(ProposeFigureFailure)
     expect(failure.message).toBe('The figure could not be made.')
     expect(failure.attempts).toBe(3)
     expect(failure.reasons).toEqual(['The answer must be { "steps": [ ... ] }.'])
     expect(client.calls).toBe(3)
-    expect(client.sent[2]!.at(-1)!.content).toMatch(/not valid JSON: cut short/)
+    expect(client.sent[2]!.at(-1)!.content).toMatch(/not valid JSON: no balanced JSON found/)
+  })
+
+  /*
+    Only an answer that is not JSON is asked again (figure audit 2026-10-16 N2). A request that failed -- a rejected key,
+    a rate limit, a dropped connection -- was asked three times and said as "not valid JSON"; now it is said as it is,
+    once, and the tool's caller hears the provider's own words.
+  */
+  /*
+    :3300, 2026-10-16, a real model: three answers refused with "TARGET_ABSENT: steps[12]: attach: joints.frame: frame is
+    not a placed part". The kernel says the same for a part never added and a part not placed yet, so the writer is told
+    which parts there were at the refused step, and fastens to one of them.
+  */
+  it('a step that names a part not there is said back with the parts there were at that step', () => {
+    const steps = [...liftTable.slice(0, 3), { kind: 'attach', part: 'column', face: 'bottom', to: { part: 'frame', face: 'top' } }]
+    const { reasons } = judgeFigureAnswer(createFigureAsset('Lift table'), { steps }, false)
+    expect(reasons).toHaveLength(1)
+    expect(reasons[0]).toMatch(/^TARGET_ABSENT: steps\[3\]/)
+    expect(reasons[0]).toContain('The parts at steps[3] are: base, column, top.')
+    /* The kernel's sentence ends without a stop; the two sentences are not run together (:3300 "...here The parts"). */
+    expect(reasons[0]).toMatch(/[.!?] The parts at steps\[3\]/)
+  })
+
+  it('a request that failed is not asked again, and is said as it failed', async () => {
+    const refused = Object.assign(new Error('401 Unauthorized'), { status: 401 })
+    const client = stubClient([refused, { steps: liftTable }])
+    const failure = await proposeFigureSteps({ client, prompt: '리프트 테이블', name: 'Lift table' }).catch(e => e)
+    expect(failure).toBe(refused)
+    expect(client.calls).toBe(1)
+  })
+
+  it('an answer cut off at the output limit is asked again for fewer commands, not for the same', async () => {
+    const client = stubClient([new AIAnswerNotJSON('no balanced JSON found', true), { steps: liftTable }])
+    const made = await proposeFigureSteps({ client, prompt: '리프트 테이블', name: 'Lift table' })
+    expect(made.attempts).toBe(2)
+    const asked = client.sent[1]!.at(-1)!.content as string
+    expect(asked).toMatch(/cut off at the output limit/)
+    expect(asked).toMatch(/make-repeat/)
+    expect(asked).not.toMatch(/not valid JSON/)
   })
 })
 

package/server/service/figure/figure-propose-steps.ts

@@ -1,6 +1,6 @@
 import { FIGURE_PROPOSAL_GRAMMAR, applyFigureProposal, createFigureAsset, inspectFigureAsset, serializeFigureAsset, figureCostOf, figureScoreOf } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureProposalStep, FigureRefusalDetails } from '@hatiolab/figure-model'
-import type { AIClient } from '@things-factory/ai-client-base'
+import { AIAnswerNotJSON, type AIClient } from '@things-factory/ai-client-base'
 import type { AIImageMediaType, AIMessage } from '@things-factory/ai-client-base'
 
 import { figureViewOf, unreadPartEdits, unreadSectionEdits, type FigureReadRequest, type FigureView } from './figure-context.js'
@@ -86,6 +86,10 @@ export function rulesPromptFigure(): string {
     'Space: millimetres; Y is up; the figure stands on its mounting plane. Angles are degrees.',
     'A part is made at the origin and placed by fastening one of its faces to a face of another part or to the mounting',
     'plane. Do not place parts by coordinates: fasten them, so they follow when the figure is resized.',
+    'Fasten each part once, and fasten only to the mounting plane or to a part an earlier step added; to move a part',
+    'already fastened, attach it again with replace: true.',
+    'Several of the same part in a row (rollers, legs, slats) are one part and make-repeat, not a part added and fastened',
+    'for each: the row follows the figure when it is resized, and the answer stays short.',
     'A part is named by its id; use lowercase words joined by hyphens. Name only parts that exist or that an earlier step adds.',
     'A colour is a palette token. A token the figure does not have yet is given with its colour on the same command:',
     '{ kind: "set-material", target, material: { token }, palette: { [token]: "#rrggbb" } }.',
@@ -162,6 +166,29 @@ function worseThan(now: Violation, before: Violation): string | undefined {
   return undefined
 }
 
+/**
+ * The parts there were at the step the kernel refused, said after its refusal. The kernel says "is not a placed part" of
+ * a part never added and of one not placed yet alike (:3300, 2026-10-16: three answers refused so, the writer never told
+ * which names there were); with the names before it, the writer fastens to one of them. Nothing for a refusal not at a
+ * step, or a step whose earlier steps cannot be replayed.
+ */
+/** How many part names a refusal is told with: a figure of hundreds of parts is not listed whole on every retry. */
+const PARTS_NAMED = 80
+
+function partsAtRefusedStep(base: FigureAsset, steps: FigureProposalStep[], error: unknown): string {
+  const at = /^steps\[(\d+)\]$/.exec(String((error as { path?: unknown })?.path ?? ''))
+  if (!at) return ''
+  const step = Number(at[1])
+  try {
+    const before = applyFigureProposal(base, steps.slice(0, step))
+    const parts = before.appearance.map(look => look.target)
+    const named = parts.slice(0, PARTS_NAMED).join(', ') + (parts.length > PARTS_NAMED ? ` and ${parts.length - PARTS_NAMED} more` : '')
+    return ` The parts at steps[${step}] are: ${parts.length ? named : 'none'}.`
+  } catch {
+    return ''
+  }
+}
+
 /**
  * Applies an answer on a copy of the base and returns the figure, or the reasons it was not accepted: the step the
  * kernel refused, or the gate findings the steps brought in. When revising, a finding the draft already had is not the
@@ -199,7 +226,10 @@ export function judgeFigureAnswer(
           `CLIPS_DROPPED: these steps would stop the clips ${clips.map(c => `${c.clip} (plays ${c.state})`).join(', ')}. A proposal may never remove a clip; only the person can. Keep the parts and the motions those clips play as they are.`
         ]
       }
-    return { reasons: [(e as Error).message] }
+    const said = (e as Error).message
+    const parts = partsAtRefusedStep(base, steps as FigureProposalStep[], e)
+    /* The kernel's sentence may end without a stop; the next one is not run into it. */
+    return { reasons: [parts && !/[.!?]$/.test(said) ? `${said}.${parts}` : `${said}${parts}`] }
   }
 
   /* What the steps did to a section the writer was not shown, judged on the figure they made. */
@@ -247,7 +277,17 @@ export async function proposeFigureSteps(input: ProposeFigureInput): Promise<Pro
     try {
       answer = await client.generateJSON(messages, { systemPrompt: system, maxTokens: GENERATE_MAX_TOKENS })
     } catch (e) {
-      reasons = [`The answer was not valid JSON: ${(e as Error).message}`]
+      /*
+        Only an answer that is not JSON is asked again (figure audit 2026-10-16 N2). A request that failed -- a rejected
+        key, a rate limit, a dropped connection -- goes up as it failed: asked again it fails again, and said as "not
+        valid JSON" it names a cause it did not have.
+      */
+      if (!(e instanceof AIAnswerNotJSON)) throw e
+      reasons = [
+        e.cutShort
+          ? `The answer was cut off at the output limit (${GENERATE_MAX_TOKENS} tokens) before the JSON ended. Write fewer commands: repeat a part with make-repeat instead of adding each copy, and write only what the request needs.`
+          : `The answer was not valid JSON: ${e.message}`
+      ]
       messages.push({ role: 'user', content: ['That was rejected. Answer with the JSON object only:', ...reasons].join('\n') })
       continue
     }

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

@@ -176,3 +176,52 @@ describe('a picture sent in the dock', () => {
     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\]/)
+  })
+})