@things-factory/figure-service 10.1.9 → 10.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.9",
+  "version": "10.1.13",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -32,5 +32,5 @@
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "ccbb6cfee4f73360a863d17f58a6c4134221dae1"
+  "gitHead": "f2cd3d27e32e71cca1d3af5499ef54249b1cc111"
 }

package/server/service/figure/figure-ai-flow.test.ts

@@ -69,8 +69,7 @@ test('초안·세션 피드백을 반영한 후보가 검증·품질 근거와
   const result = await propose.builder(
     { prompt: '포트가 더 잘 읽히도록 고쳐줘' },
     {
-      state: {
-        domain: DOMAIN,
+      state: { domain: DOMAIN },
         host: {
           figureId: 'fig-1',
           palette: ['palette.primary'],
@@ -81,7 +80,6 @@ test('초안·세션 피드백을 반영한 후보가 검증·품질 근거와
             quality: { status: 'review', findingCodes: ['top-view-readability'] }
           }]
         }
-      }
     }
   )
 

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

@@ -12,7 +12,7 @@
  *
  * 실제 모델은 부르지 않는다. 여기서 볼 것은 모델의 솜씨가 아니라 **우리 배선**이다.
  */
-import { clearToolRegistry, getToolCategories } from '@things-factory/ai-client-base'
+import { clearToolRegistry, getToolCategories, registryAssistantChat } from '@things-factory/ai-client-base'
 
 import { __setFigureToolDepsForTest, registerFigureToolCategories } from './figure-tools'
 
@@ -91,7 +91,7 @@ function toolNamed(name: string) {
 }
 
 const ctx = (host: any = { figureId: 'fig-1', palette: ['palette.primary'] }) => ({
-  state: { domain: MINE, host }
+  state: { domain: MINE }, host
 })
 
 beforeEach(() => {
@@ -103,6 +103,25 @@ beforeEach(() => {
 
 afterEach(() => clearToolRegistry())
 
+test('실제 registryAssistantChat 경계가 열린 모델 문맥을 Figure 도구에 전달한다', async () => {
+  const seen: any[] = []
+  let turn = 0
+  await registryAssistantChat({
+    client: { chatWithTools: async (messages: any[]) => {
+      seen.push(messages)
+      return turn++ === 0
+        ? { toolCalls: [{ id: 'read-1', name: 'getFigureSource', arguments: {}, type: 'tool_use' }], stopReason: 'tool_use' }
+        : { text: '조회했습니다.', toolCalls: [], stopReason: 'end_turn' }
+    } } as any,
+    messages: [{ role: 'user', content: '현재 모델을 조회해줘' }],
+    systemPrompt: 'Read the current figure.', toolCategories: ['figure-authoring'],
+    state: { domain: MINE }, hostContext: { figureId: 'fig-1', draftSource: SOURCE }
+  })
+  expect(seen).toHaveLength(2)
+  expect(JSON.stringify(seen[1])).toContain('MIXER')
+  expect(JSON.stringify(seen[1])).not.toContain('FIGURE_TARGET_REQUIRED')
+})
+
 describe('범주가 등록된다', () => {
   it('figure-authoring 이 도구 넷과 함께 올라온다', () => {
     const category = getToolCategories().find((one: any) => one.name === 'figure-authoring')!
@@ -160,8 +179,20 @@ describe('대화면 문맥에서 대상을 해소한다', () => {
     expect(result.source.type).toBe('MIXER')
   })
 
-  it('열린 도형도 없고 id 도 없으면 명시 실패한다 — 아무 도형이나 고르지 않는다', async () => {
-    await expect(toolNamed('getFigureSource').builder({}, ctx({}))).rejects.toThrow(/figureId is required/)
+  it.each(['getFigureSource', 'inspectFigure'])('%s: 목록의 대상 누락은 채팅을 끊지 않고 다음 동작을 안내한다', async name => {
+    const result = await toolNamed(name).builder({}, ctx({}))
+    expect(result.error).toBe('FIGURE_TARGET_REQUIRED')
+    expect(result.nextStep).toContain('listFigures')
+    expect(result.nextStep).toContain('create: true')
+    expect(result.source).toBeUndefined()
+  })
+
+  it('목록에서 대상을 찾아 다시 호출하면 해당 도형의 정본을 읽는다', async () => {
+    const catalog = await toolNamed('listFigures').builder({}, ctx({}))
+    const target = catalog.figures.find((figure: any) => figure.name === '믹서')
+    const result = await toolNamed('getFigureSource').builder({ figureId: target.id }, ctx({}))
+    expect(result.id).toBe('fig-1')
+    expect(result.source.type).toBe('MIXER')
   })
 
   it('정본이 없는 도형은 없다고 말한다 — 지어내지 않는다', async () => {
@@ -246,6 +277,43 @@ describe('모델이 넘긴 id 를 믿지 않는다', () => {
 })
 
 describe('후보를 요청할 때', () => {
+  it('저장 전 새 모델도 현재 초안을 읽고 수정 후보의 기반으로 사용한다', async () => {
+    const host = { editorMode: 'new', draftSource: SOURCE, palette: ['palette.primary'] }
+    const read = await toolNamed('getFigureSource').builder({}, ctx(host))
+    expect(read.source).toEqual(SOURCE)
+    expect(read.draft).toBe(true)
+    const result = await toolNamed('proposeFigureCandidate').builder({ prompt: '몸체를 키워줘' }, ctx(host))
+    expect(proposed[0].base).toEqual(SOURCE)
+    expect(result.args.draftType).toBe('MIXER')
+    expect(result.args.figureId).toBeUndefined()
+  })
+
+  it('목록에 남은 새 모델 초안은 현재 모델로 사용하지 않는다', async () => {
+    const result = await toolNamed('getFigureSource').builder({}, ctx({ editorMode: 'catalog', draftSource: SOURCE }))
+    expect(result.error).toBe('FIGURE_TARGET_REQUIRED')
+  })
+
+  it('목록에서 새 제작은 기존 도형을 요구하지 않는다', async () => {
+    const result = await toolNamed('proposeFigureCandidate').builder(
+      { prompt: '믹서를 새로 만들어줘', create: true }, ctx({ palette: ['palette.primary'] })
+    )
+    expect(result.proposed).toBe(true)
+    expect(proposed[0].base).toBeUndefined()
+  })
+
+  it('figureId null은 도구 설명대로 새 제작을 의미한다', async () => {
+    await toolNamed('proposeFigureCandidate').builder({ prompt: '새로 만들어줘', figureId: null }, ctx())
+    expect(proposed[0].base).toBeUndefined()
+  })
+
+  it('다른 도형을 지정하면 열린 도형의 미저장 초안을 섞지 않는다', async () => {
+    const result = await toolNamed('getFigureSource').builder(
+      { figureId: 'fig-blank' }, ctx({ figureId: 'fig-1', draftSource: SOURCE })
+    )
+    expect(result.id).toBe('fig-blank')
+    expect(result.source).toBeNull()
+  })
+
   it('열린 도형이 있으면 고치는 것으로 본다 — 그 정본이 함께 나간다', async () => {
     await toolNamed('proposeFigureCandidate').builder({ prompt: '재질을 줄여줘' }, ctx())
 

package/server/service/figure/figure-tools.ts

@@ -101,7 +101,7 @@ async function figureInDomain(figureId: string, domainId: string): Promise<any>
  * 프롬프트로 옮기면 비용만 태우고, DB에 있던 Figure와 다른 것을 고친다고 잘못 말할 수 있다.
  */
 function sourceForTool(row: any, host: any): { source: any; draft: boolean } {
-  const draft = host?.draftSource
+  const draft = host?.figureId === row.id ? host?.draftSource : undefined
   if (!draft) {
     return { source: row.source ? JSON.parse(row.source) : null, draft: false }
   }
@@ -144,20 +144,36 @@ function feedbackForTool(host: any, figureId?: string): unknown[] | undefined {
  * 모델이 대상을 안 줬으면 **저작면이 지금 열고 있는 도형**이다. 사용자에게 식별자를 되묻지
  * 않는다 — 화면에 그 도형이 떠 있는데 「어느 도형입니까」를 묻는 것은 문맥을 안 읽은 것이다.
  */
-function figureIdFrom(args: any, host: any): string {
+function figureIdFrom(args: any, host: any): string | undefined {
   const said = typeof args?.figureId === 'string' ? args.figureId.trim() : ''
   if (said) return said
 
   const open = typeof host?.figureId === 'string' ? host.figureId.trim() : ''
   if (open) return open
 
-  throw new Error('figureId is required: this surface has no figure open to resolve it from')
+  return undefined
+}
+
+function missingFigureTarget() {
+  return {
+    error: 'FIGURE_TARGET_REQUIRED',
+    message: '현재 화면에는 선택된 도형이 없습니다.',
+    nextStep: 'For an existing figure, call listFigures and match the user’s requested name or type; ask which figure only if ambiguous. For a new figure, call proposeFigureCandidate with create: true and the user’s prompt. Do not invent an id or repeat this call without a target.'
+  }
+}
+
+function unsavedFigure(host: any): any | undefined {
+  if (host?.editorMode !== 'new' || host?.figureId || !host?.draftSource) return undefined
+  const row = { id: host.figureId, type: host.draftSource.type, name: '', state: 'draft' }
+  // Reuse size, shape and vocabulary validation before trusting browser content.
+  const current = sourceForTool(row, host)
+  return { ...row, source: JSON.stringify(current.source) }
 }
 
 const FIGURE_ID_ARG = {
   figureId: {
     type: 'string',
-    description: 'The figure to read. Omit to use the one open in the editor.'
+    description: 'The figure to read. Omit when host context has an open figureId or an unsaved new editor draft. On the catalog, first resolve the user’s requested figure with listFigures.'
   }
 } as const
 
@@ -206,10 +222,11 @@ function figureToolSpecs(): ToolSpec[] {
       schema: { type: 'object', properties: { ...FIGURE_ID_ARG } },
       builder: async (args: any, ctx: any) => {
         const domainId = requireDomainId(ctx?.state)
-        const figureId = figureIdFrom(args, ctx?.state?.host)
-        const row = await figureInDomain(figureId, domainId)
+        const figureId = figureIdFrom(args, ctx?.host)
+        const row = figureId ? await figureInDomain(figureId, domainId) : unsavedFigure(ctx?.host)
+        if (!row) return missingFigureTarget()
 
-        const current = sourceForTool(row, ctx?.state?.host)
+        const current = sourceForTool(row, ctx?.host)
         if (!current.source) {
           // 저장된 정본이 없는 상태가 실제로 있다(새로 만들고 저장 안 한 것). 지어내지 않는다.
           return { id: row.id, type: row.type, name: row.name, source: null, cost: null }
@@ -240,10 +257,11 @@ function figureToolSpecs(): ToolSpec[] {
       schema: { type: 'object', properties: { ...FIGURE_ID_ARG } },
       builder: async (args: any, ctx: any) => {
         const domainId = requireDomainId(ctx?.state)
-        const figureId = figureIdFrom(args, ctx?.state?.host)
-        const row = await figureInDomain(figureId, domainId)
+        const figureId = figureIdFrom(args, ctx?.host)
+        const row = figureId ? await figureInDomain(figureId, domainId) : unsavedFigure(ctx?.host)
+        if (!row) return missingFigureTarget()
 
-        const current = sourceForTool(row, ctx?.state?.host)
+        const current = sourceForTool(row, ctx?.host)
         const { inspectSource } = getDeps()
         return { ...inspectSource(current.source ? JSON.stringify(current.source) : null), draft: current.draft }
       }
@@ -288,15 +306,18 @@ function figureToolSpecs(): ToolSpec[] {
           후보가 온다.
         */
         let base: unknown
-        if (!args?.create) {
-          const open = typeof args?.figureId === 'string' ? args.figureId : ctx?.state?.host?.figureId
+        if (!args?.create && args?.figureId !== null) {
+          const open = typeof args?.figureId === 'string' ? args.figureId : ctx?.host?.figureId
           if (typeof open === 'string' && open.trim()) {
             const row = await figureInDomain(open.trim(), domainId)
-            base = sourceForTool(row, ctx?.state?.host).source ?? undefined
+            base = sourceForTool(row, ctx?.host).source ?? undefined
+          } else {
+            const draft = unsavedFigure(ctx?.host)
+            if (draft) base = JSON.parse(draft.source)
           }
         }
 
-        const palette = Array.isArray(ctx?.state?.host?.palette) ? ctx.state.host.palette : []
+        const palette = Array.isArray(ctx?.host?.palette) ? ctx.host.palette : []
         if (palette.length === 0) {
           /*
             팔레트를 모르면 모델이 색을 지어내고, 그 후보는 그리는 시점에 `resolveToken` 이 던진다 —
@@ -306,7 +327,7 @@ function figureToolSpecs(): ToolSpec[] {
         }
 
         const { proposeFigure } = getDeps()
-        const feedback = feedbackForTool(ctx?.state?.host, base ? figureIdFrom(args, ctx?.state?.host) : undefined)
+        const feedback = feedbackForTool(ctx?.host, base ? figureIdFrom(args, ctx?.host) : undefined)
         const result = await proposeFigure({
           prompt,
           palette,
@@ -330,7 +351,12 @@ function figureToolSpecs(): ToolSpec[] {
           reason:
             `등급 ${result.score.grade} · 삼각형 ${result.cost.triangles} · ` +
             `한 도면 ${result.cost.at.drawCalls}회 · ${result.attempts}번에 만들었다`,
-          args: { prompt, figureId: base ? figureIdFrom(args, ctx?.state?.host) : undefined },
+          args: {
+            baseSource: base ? JSON.stringify(base) : undefined,
+            prompt, figureId: base ? figureIdFrom(args, ctx?.host) : undefined,
+            draftType: base && ctx?.host?.editorMode === 'new' && !figureIdFrom(args, ctx?.host)
+              ? (base as any).type : undefined
+          },
           source: result.source,
           score: result.score,
           cost: result.cost,
@@ -356,10 +382,14 @@ export function registerFigureToolCategories(): void {
     description: '저작 중인 Figure 의 정본·비용·발행 판정 조회와 후보 제안(저장 아님).',
     guidance: [
       '- **도형을 만들거나 고쳐 달라는 요청에는 반드시 `proposeFigureCandidate` 를 호출한다.**',
+      '  후보는 도구 호출 결과에서만 생긴다.',
       '  호출 없이 "후보를 만들었습니다" · "적용 버튼을 누르세요" 라고 쓰는 것은 **거짓이다** — 화면에 후보 칸이 생기지 않으므로 사용자는 존재하지 않는 버튼을 찾는다.',
-      '  후보 화면(「지금 / 후보」 두 칸)은 **도구 호출 결과에서만** 만들어진다. 문장으로는 아무 일도 일어나지 않는다.',
+      '  도크에서는 후보 카드의 버튼을 눌러야 모델러 비교 화면이 열린다. 아직 열지 않은 비교 화면이 이미 보인다고 말하지 않는다.',
+      '  요청한 부품만 바뀌었다고 추측하지 않는다. 후보와 원본을 비교한 근거가 없으면 변경 범위는 비교 화면에서 확인하도록 안내한다.',
       '- 정본을 직접 저장하지 않는다. 후보만 내고, 받을지 버릴지는 저작자가 화면에서 정한다.',
+      '- 좌표와 크기는 X/Y/Z 축 이름으로 정확하게 표시한다. 확인되지 않은 가로·세로·높이 의미를 임의로 붙이지 않는다.',
       '- **고치라는 요청이면 먼저 `getFigureSource` 를 부른다.** 읽지 않고 고치면 짐작을 상대로 후보를 내게 되고, 부품 이름이 갈려 이미 배치된 보드의 바인딩이 끊긴다.',
+      '- 목록 화면에는 열린 도형이 없다. 기존 도형을 조회·수정할 때는 `listFigures`에서 사용자가 말한 이름·타입의 id를 찾는다. 대상이 모호할 때만 어느 도형인지 묻는다. 새 제작 요청에는 기존 정본을 조회하지 않고 `proposeFigureCandidate`를 create: true로 호출한다.',
       '- 타입 이름을 지어내지 않는다 — `listFigures` 로 확인한다. **타입 이름은 저장되는 식별자**이고 보드가 그 이름으로 도형을 찾는다.',
       '- 발행이 안 되는 이유를 물으면 `inspectFigure` 를 부른다. 판정 없이 "발행할 수 있습니다"라고 말하지 않는다.',
       '  판정의 각 항목은 **왜 문제인지와 무엇을 바꾸면 되는지**를 함께 담고 있다. 그대로 전한다 — 요약하면 저작자가 어느 부품의 어느 축을 고칠지 다시 찾아야 한다.',