@things-factory/ai-assistant 10.1.8 → 10.1.13

package/docs/session-controller.md

@@ -0,0 +1,52 @@
+# Shared assistant session lifecycle
+
+Figure and Plant use `AssistantSessionController` and `assistantSessionTransport` from the client entry point. `ox-assistant-session-toolbar` supplies history selection, reset, loading/error status and retry controls. Existing shared Board chat uses the same toolbar while forwarding the existing `session-switch` and `session-create` events; its collaboration-specific server adapter is not replaced by the private inbox transport.
+
+## Responsibilities
+
+### Lazy creation (Figure/Plant)
+
+Pass `{lazy:true}` as the controller's fourth constructor argument. Opening an empty inbox returns a temporary conversation without writing. Reset clears the active ID and preserves history; repeated reset stays temporary. A draft selection is remembered across reloads. Use `prepareSession(adopt)` only immediately before a real message send. It creates the session and invokes `adopt(id)` before publishing the ID to the host.
+
+Shared chat exposes a `prepareSession` property. Its send path waits for creation, preserves the input on failure, and adopts the first ID without clearing pending input or loading empty history over the first message. Hosts must retain the same chat element during this promotion; do not key-remount it when the initial ID arrives. Actual target/session switches must still replace or clear the chat. Legacy consumers without lazy mode retain their previous lifecycle.
+
+Session creation and message persistence are separate requests: a network failure between them can still leave a recoverable empty session. This is not an atomic guarantee. Existing empty sessions are not deleted automatically.
+
+The framework lists/resumes sessions, creates only after a successful empty inbox, remembers selection, starts new conversations without deleting old ones, and rejects stale UI updates. A target comprises authenticated user/domain `scope`, `anchorType`, and `anchorId`. Optional browser session storage remembers selection across reloads. Storage contains session IDs, not messages; server authorization remains authoritative.
+
+The product adapter supplies the target, current editing context, labels, tools and proposal application. Figure uses figure/application anchors; Plant retains board/domain anchors. The controller does not navigate, modify models, or choose product tools. An undefined target is a temporary conversation; consumers recreate its chat view when reset increments `revision`.
+
+## Flow and failure handling
+
+Host target → controller.open → authorized inbox → existing selection or create on empty → shared chat sessionId.
+
+Same-target pending loads coalesce. A late response cannot overwrite the active target; an abandoned empty read cannot trigger creation. A failed list never becomes an empty list. Reset failure preserves the previous session. Call `clear()` at identity teardown; scope must include account and domain, not only the document ID.
+
+Reset in lazy mode selects a temporary conversation; its first send creates a session. Legacy non-lazy mode creates immediately. Old history remains selectable. Only the selected session history is sent in subsequent requests, while system instructions, tools and current model context still incur normal token costs. Reset does not cancel an already-submitted request or delete its server messages.
+
+## Limits and follow-up
+
+The default inbox reads up to 100 sessions. Selection outside that window needs a paginated/history-search UI before claiming unlimited restoration. Browser storage is optional and tab-local; unavailable storage falls back to memory. Multi-tab initial empty creation is not server-idempotent. Full legacy Board lifecycle migration needs a collaboration-aware transport (including its existing idempotent initial-session API), not the private `mineOnly` inbox used by Figure and Plant.
+
+## Shared toolbar contract
+
+Properties: `sessions`, `sessionId`, `loading`, `error`, `temporary`, `disabled`.
+Events: `assistant-session-select` with `{sessionId}`, `assistant-session-reset`, `assistant-session-retry`. Events bubble across shadow roots. The toolbar performs no API mutations. Busy state disables controls; temporary state hides persisted history selection. It never deletes document data or history.
+
+Opt-in `historyEnabled` adds an `assistant-session-history` event button and limits visible tabs to `maxTabs` (default 5), retaining the selected older conversation. The host owns its authorized, paginated history UI; this button does not implement unlimited history retrieval.
+
+## Send-time context and proposal safety
+
+Shared chat accepts synchronous `contextProvider(): {systemPrompt?, hostContext?}` on every send. Throwing blocks the message and retains input. `boardProvider` independently supplies the live model. Both values are cloned before sending. Lazy session creation currently precedes this validation and may leave an empty session if validation fails.
+
+`autoAskRequestId` distinguishes repeated identical user requests; generate it per user submission, not per render. Without it, legacy text-based deduplication remains.
+
+`board-edit-patch` and `board-action-execute` include local `detail.requestBase = {version: 1, sessionId, hostContext, modelFingerprint}`. `assistantModelFingerprint` returns a deterministic JSON signature, not a security hash. Undefined models have no signature. Hosts must validate target identity and compare the current model signature before applying a proposal. This metadata is not persisted into restored history; missing metadata is not proof that a historical proposal is safe. The framework captures the evidence but does not implement product-specific application guards.
+
+Figure browser verification after toolbar migration: selected old session, reset to session 3, observed sessions 1 and 2 retained; screenshot confirmed aligned controls. Models were not edited. Plant runtime validation is owned by its development task. Legacy Board forwarding has source-contract coverage, not full Board browser coverage.
+
+## Verification
+
+`node --experimental-strip-types --test packages/ai-assistant/test/assistant-session-controller.test.ts`
+
+Tests cover load failure/retry, coalescing, late target responses, reset failure, preserved history, reload selection, scope separation and disposal. Browser verification is still required for each host's routing and document-context adapter.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.8",
+  "version": "10.1.13",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -44,5 +44,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "c402982e29aab3b49e56bea4e41948be6a749c7f"
+  "gitHead": "f2cd3d27e32e71cca1d3af5499ef54249b1cc111"
 }

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

@@ -31,6 +31,7 @@ import { getRepository } from '@things-factory/shell'
 import { createAIClient, getDefaultAIClient, registryAssistantChat, type AIClient } from '@things-factory/ai-client-base'
 
 import { ChatSession } from './chat-session/chat-session.js'
+import { assertStationSession } from './chat-session/station-session-guard.js'
 import { ChatMessage } from './chat-message/chat-message.js'
 import { buildLlmHistory } from './chat-message/llm-history.js'
 import { publishChatMessage } from './chat-message/chat-message-publish.js'
@@ -200,9 +201,17 @@ export class AssistantChatResolver {
     if (input.sessionId) {
       const found = await sessionRepo.findOneBy({ id: input.sessionId, domain: { id: domain.id } as any })
       if (!found) throw new Error(`ChatSession ${input.sessionId} not found`)
+      if (found.anchorType === 'figure' && input.hostContext?.figureId !== found.anchorId) {
+        throw new Error('이 대화는 다른 Figure의 이력입니다. 현재 모델의 대화를 다시 여세요.')
+      }
+      if (found.anchorType === 'application' && (input.hostContext?.app !== found.anchorId || input.hostContext?.figureId)) {
+        throw new Error('애플리케이션 대화와 모델 대화를 구분해서 다시 여세요.')
+      }
       session = found
     }
 
+    assertStationSession(session, input.hostContext)
+
     const lastUserMessage = input.messages[input.messages.length - 1]
     let userMessageId: string | undefined
 

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

@@ -80,7 +80,7 @@ export class ChatSession {
   @Field({
     nullable: true,
     description:
-      "What this conversation is anchored to: 'board' (authoring a board) | 'space' (a site and the twins running there) | 'instance' | 'none'. Absent on legacy rows — treated as 'board' when boardId is present."
+      "What this conversation is anchored to: 'board' | 'figure' (authoring a Figure) | 'space' | 'instance' | 'domain' | 'none'. Absent on legacy rows — treated as 'board' when boardId is present."
   })
   anchorType?: string
 

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

@@ -52,7 +52,9 @@
  *   domain    테넌트 전체가 주제인 대화 — 공장 전체 문답처럼 더 좁게 가리킬 것이 없을 때
  *   none      앵커로 찾을 수 없는 대화. 「아직 아무것도 고르지 않았다」는 화면 상태다
  */
-export const SESSION_ANCHOR_TYPES = ['board', 'space', 'instance', 'domain', 'none'] as const
+// Figure-specific history requested explicitly: reuse the existing varchar
+// anchor columns, without writing Figure ids into the legacy boardId column.
+export const SESSION_ANCHOR_TYPES = ['board', 'figure', 'application', 'space', 'instance', 'domain', 'none'] as const
 
 export type SessionAnchorType = (typeof SESSION_ANCHOR_TYPES)[number]
 

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

@@ -0,0 +1,17 @@
+/** Station authoring must never append its design snapshot to another subject's history.
+ * This is a consistency check, not authorization; tenant/privilege checks stay in the resolver.
+ * Older Board sessions have only boardId, so preserve that supported read shape.
+ */
+export function assertStationSession(
+  session: {anchorType?:string|null;anchorId?:string|null;boardId?:string|null}|undefined,
+  host: {surface?:string;boardId?:unknown}|undefined
+) {
+  if(host?.surface!=='station-screen-modeller')return
+  const boardId=host.boardId
+  const legacy=Boolean(session&&!session.anchorType&&session.boardId)
+  const valid=typeof boardId==='string'&&boardId.length>0&&session&&
+    (session.anchorType==='board'||legacy)&&
+    (session.anchorId||session.boardId)===boardId&&
+    (!session.boardId||session.boardId===boardId)
+  if(!valid)throw new Error('현재 Station Screen과 대화 이력이 일치하지 않습니다. 해당 화면의 대화를 다시 여세요.')
+}

package/server/service/session-anchor.test.ts

@@ -108,6 +108,17 @@ describe('anchor types are checked, not cast', () => {
 })
 
 describe('앵커 조회 조건 (anchorWhere)', () => {
+  it('애플리케이션 대화는 모델 및 다른 제품·도메인과 분리한다', () => {
+    expect(anchorColumns('application', 'operato-figure')).toEqual({ anchorType: 'application', anchorId: 'operato-figure', boardId: undefined })
+    expect(anchorWhere('D1', 'application', 'operato-figure')).not.toEqual(anchorWhere('D1', 'figure', 'F1'))
+    expect(anchorWhere('D1', 'application', 'operato-figure')).not.toEqual(anchorWhere('D1', 'application', 'operato-plant'))
+  })
+  it('Figure 이력은 같은 id의 Board 및 다른 도메인과 분리한다', () => {
+    expect(anchorColumns('figure', 'F1')).toEqual({ anchorType: 'figure', anchorId: 'F1', boardId: undefined })
+    expect(anchorWhere('D1', 'figure', 'F1')).toEqual({ anchorType: 'figure', anchorId: 'F1', domain: { id: 'D1' } })
+    expect(anchorWhere('D2', 'figure', 'F1')).not.toEqual(anchorWhere('D1', 'figure', 'F1'))
+    expect(() => anchorColumns('figure', '')).toThrow()
+  })
   it('board 앵커는 boardId 로 찾는다 — 앵커 컬럼이 빈 옛 행도 잡힌다', () => {
     /* 신규 행은 dual-write 로 boardId 도 채워지므로 같은 조건에 함께 걸린다. */
     expect(anchorWhere('dom-1', 'board', 'B1')).toEqual({ boardId: 'B1', domain: { id: 'dom-1' } })

package/server/service/station-session-guard.test.ts

@@ -0,0 +1,24 @@
+import { assertStationSession } from './chat-session/station-session-guard'
+
+describe('Station authoring session boundary',()=>{
+  const host={surface:'station-screen-modeller',boardId:'A'}
+  it('accepts matching Board and legacy Board sessions',()=>{
+    expect(()=>assertStationSession({anchorType:'board',anchorId:'A',boardId:'A'},host)).not.toThrow()
+    expect(()=>assertStationSession({boardId:'A'},host)).not.toThrow()
+  })
+  it('rejects a different Board or inconsistent dual-write fields',()=>{
+    expect(()=>assertStationSession({anchorType:'board',anchorId:'B'},host)).toThrow(/일치/)
+    expect(()=>assertStationSession({anchorType:'board',anchorId:'A',boardId:'B'},host)).toThrow(/일치/)
+  })
+  it('rejects missing session, missing Board id and other anchor types',()=>{
+    expect(()=>assertStationSession(undefined,host)).toThrow(/일치/)
+    expect(()=>assertStationSession({anchorType:'board',anchorId:'A'},{surface:host.surface})).toThrow(/일치/)
+    for(const anchorType of ['domain','application','figure','none']){
+      expect(()=>assertStationSession({anchorType,anchorId:'A'},host)).toThrow(/일치/)
+    }
+  })
+  it('does not change other consumers of assistantChat',()=>{
+    expect(()=>assertStationSession(undefined,undefined)).not.toThrow()
+    expect(()=>assertStationSession({anchorType:'domain',anchorId:'D'},{surface:'plant-operations'})).not.toThrow()
+  })
+})

package/test/assistant-request-context.test.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { readFileSync } from 'node:fs'
+import { assistantAutoAskKey, assistantModelFingerprint, assistantRecentSessions } from '../client/utils/assistant-request-context.ts'
+
+test('model signature ignores object key order but detects nested edits and array order', () => {
+  assert.equal(assistantModelFingerprint({ b: 2, a: { y: 3, x: 1 } }), assistantModelFingerprint({ a: { x: 1, y: 3 }, b: 2 }))
+  assert.notEqual(assistantModelFingerprint({ parts: [{ x: 1 }] }), assistantModelFingerprint({ parts: [{ x: 2 }] }))
+  assert.notEqual(assistantModelFingerprint([1, 2]), assistantModelFingerprint([2, 1]))
+  assert.equal(assistantModelFingerprint(undefined), undefined)
+})
+test('identical text with a new request ID is a new send', () => {
+  assert.equal(assistantAutoAskKey('hello'), 'hello')
+  assert.equal(assistantAutoAskKey('hello', 'one'), assistantAutoAskKey('hello', 'one'))
+  assert.notEqual(assistantAutoAskKey('hello', 'one'), assistantAutoAskKey('hello', 'two'))
+})
+test('recent tabs retain the selected older conversation without mutating the inbox', () => {
+  const sessions = ['a', 'b', 'c', 'd'].map(id => ({ id }))
+  assert.deepEqual(assistantRecentSessions(sessions, 'd', 3).map(s => s.id), ['a', 'b', 'd'])
+  assert.deepEqual(sessions.map(s => s.id), ['a', 'b', 'c', 'd'])
+  assert.deepEqual(assistantRecentSessions([], '', 5), [])
+})
+test('send captures current context before optimistic input and attaches request base to edit events', () => {
+  const chat = readFileSync(new URL('../client/components/board-ai-chat.ts', import.meta.url), 'utf8')
+  const send = chat.slice(chat.indexOf('private async send()'))
+  assert.ok(send.indexOf('this.contextProvider?.()') < send.indexOf('// optimistic'))
+  assert.match(send, /modelFingerprint: assistantModelFingerprint\(liveBoard\)/)
+  assert.match(send, /detail: \{ actions: out.actions, sessionId: out.sessionId, requestBase \}/)
+  assert.match(send, /requestContext\.hostContext/)
+})

package/test/assistant-session-controller.test.ts

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { AssistantSessionController, type AssistantSession, type AssistantSessionTarget } from '../client/utils/assistant-session-controller.ts'
+
+const target = (id: string, scope = 'user:domain'): AssistantSessionTarget => ({ scope, anchorType: 'figure', anchorId: id })
+test('lazy open/reset never persist; first send creates once and adopts before publish', async () => {
+  let creates = 0, adopted = ''
+  const c = new AssistantSessionController({ list: async () => [], create: async () => ({ id: `s${++creates}` }) }, state => {
+    if (state.sessionId) assert.equal(adopted, state.sessionId)
+  }, undefined, { lazy: true })
+  await c.open(target('new')); await c.reset(); await c.reset()
+  assert.equal(creates, 0); assert.equal(c.state.sessionId, '')
+  await c.prepareSession(id => { adopted = id })
+  assert.equal(creates, 1); assert.equal(c.state.sessionId, 's1')
+  await c.reset(); assert.equal(creates, 1); assert.equal(c.state.sessions.length, 1)
+})
+test('failed first-send creation preserves temporary state and can retry', async () => {
+  let fail = true
+  const c = new AssistantSessionController({ list: async () => [], create: async () => { if (fail) throw Error('offline'); return { id:'ok' } } }, () => {}, undefined, { lazy:true })
+  await c.open(target('new')); await assert.rejects(c.prepareSession(), /offline/)
+  assert.equal(c.state.sessionId, ''); fail = false
+  assert.equal(await c.prepareSession(), 'ok')
+})
+test('empty conversation is reused on repeated reset', async () => {
+  let creates = 0
+  const c = new AssistantSessionController({ list: async () => [{ id:'empty' }], isEmpty: async () => true,
+    create: async () => ({ id: String(++creates) }) }, () => {})
+  await c.open(target('a')); await c.reset(); await c.reset()
+  assert.equal(creates, 0); assert.equal(c.state.sessionId, 'empty')
+})
+const deferred = <T>() => { let resolve!: (value: T) => void; const promise = new Promise<T>(r => { resolve = r }); return { promise, resolve } }
+test('empty successful inbox creates once; repeated same-target loads coalesce', async () => {
+  const d = deferred<AssistantSession[]>()
+  let creates = 0, lists = 0
+  const c = new AssistantSessionController({ list: () => { lists++; return d.promise }, create: async () => ({ id: `new${++creates}` }) }, () => {})
+  const first = c.open(target('a')); const second = c.open(target('a'))
+  d.resolve([]); await Promise.all([first, second])
+  assert.equal(lists, 1); assert.equal(creates, 1); assert.equal(c.state.sessionId, 'new1')
+})
+test('failed inbox never creates a replacement; retry recovers', async () => {
+  let fail = true, creates = 0
+  const c = new AssistantSessionController({ list: async () => { if (fail) throw Error('denied'); return [{ id: 'old' }] }, create: async () => ({ id: `${++creates}` }) }, () => {})
+  await c.open(target('a')); assert.equal(c.state.error, 'denied'); assert.equal(creates, 0)
+  fail = false; await c.open(target('a'), true); assert.equal(c.state.sessionId, 'old')
+})
+test('late response cannot replace current target and returning restores selected history', async () => {
+  const d = deferred<AssistantSession[]>()
+  const c = new AssistantSessionController({ list: t => t.anchorId === 'a' ? d.promise : Promise.resolve([{ id: 'b1' }, { id: 'b2' }]), create: async () => ({ id: 'new' }) }, () => {})
+  const first = c.open(target('a')); await c.open(target('b')); c.select('b2')
+  d.resolve([{ id: 'a1' }]); await first; assert.equal(c.state.sessionId, 'b2')
+  await c.open(target('a')); await c.open(target('b')); assert.equal(c.state.sessionId, 'b2')
+  assert.equal(c.select('a1'), false)
+})
+test('reset preserves history, changes ID and restores empty new session after reload', async () => {
+  const values = new Map<string, string>()
+  const storage = { getItem: (key: string) => values.get(key) || null, setItem: (key: string, value: string) => { values.set(key, value) } }
+  const transport = { list: async () => [{ id: 'old' }, { id: 'new' }], create: async () => ({ id: 'new' }) }
+  const c = new AssistantSessionController(transport, () => {}, storage)
+  await c.open(target('a')); await c.reset()
+  assert.equal(c.state.sessionId, 'new'); assert.ok(c.state.sessions.some(s => s.id === 'old'))
+  const reloaded = new AssistantSessionController(transport, () => {}, storage)
+  await reloaded.open(target('a')); assert.equal(reloaded.state.sessionId, 'new')
+  await reloaded.open(target('a', 'other-user:domain')); assert.equal(reloaded.state.sessionId, 'old')
+})
+test('late reset cannot overwrite another target', async () => {
+  const d = deferred<AssistantSession>()
+  const c = new AssistantSessionController({ list: async t => [{ id: t.anchorId }], create: () => d.promise }, () => {})
+  await c.open(target('a')); const reset = c.reset(); await c.open(target('b'))
+  d.resolve({ id: 'new-a' }); await reset; assert.equal(c.state.sessionId, 'b')
+})
+test('reset failure preserves active history; temporary reset needs no server', async () => {
+  const c = new AssistantSessionController({ list: async () => [{ id: 'old' }], create: async () => { throw Error('offline') } }, () => {})
+  await c.open(target('a')); await c.reset(); assert.equal(c.state.sessionId, 'old'); assert.equal(c.state.error, 'offline')
+  await c.open(); await c.reset(); assert.equal(c.state.revision, 1); assert.equal(c.state.error, '')
+})
+test('clear invalidates pending loads', async () => {
+  const d = deferred<AssistantSession[]>()
+  const c = new AssistantSessionController({ list: () => d.promise, create: async () => ({ id: 'new' }) }, () => {})
+  const load = c.open(target('a')); c.clear(); d.resolve([{ id: 'old' }]); await load
+  assert.equal(c.state.sessionId, ''); assert.equal(c.state.target, undefined)
+})
+test('abandoned empty inbox cannot create under the next domain', async () => {
+  const d = deferred<AssistantSession[]>()
+  let creates = 0
+  const c = new AssistantSessionController({ list: () => d.promise, create: async () => ({ id: `${++creates}` }) }, () => {})
+  const load = c.open(target('a')); c.clear(); d.resolve([]); await load
+  assert.equal(creates, 0); assert.equal(c.state.error, '')
+})

package/test/assistant-session-toolbar.test.ts

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { test } from 'node:test'
+const read = (file: string) => readFileSync(new URL(file, import.meta.url), 'utf8')
+const toolbar = read('../client/components/assistant-session-toolbar.ts')
+test('toolbar emits domain-neutral intent and never calls persistence APIs', () => {
+  for (const event of ['assistant-session-select', 'assistant-session-reset', 'assistant-session-retry']) assert.ok(toolbar.includes(event))
+  assert.doesNotMatch(toolbar, /client\.mutate|createAISession|createChatSession/)
+  assert.match(toolbar, /bubbles: true, composed: true/)
+})
+test('busy/error/temporary states and accessible controls are explicit', () => {
+  assert.match(toolbar, /this\.disabled \|\| this\.loading \|\| !!this\.error/)
+  assert.match(toolbar, /this\.temporary \? nothing/)
+  assert.match(toolbar, /aria-label=/)
+  assert.match(toolbar, /role="tablist"/)
+  assert.match(toolbar, /role="tab"/)
+  assert.doesNotMatch(toolbar, /<select/)
+  assert.match(toolbar, /role="alert"/)
+  assert.match(toolbar, /role="status"/)
+})
+test('legacy Board chat forwards shared controls through existing host events', () => {
+  const chat = read('../client/components/board-ai-chat.ts')
+  assert.match(chat, /import '\.\/assistant-session-toolbar\.js'/)
+  assert.match(chat, /<ox-assistant-session-toolbar/)
+  assert.match(chat, /event\.stopPropagation\(\); this\._onSessionTabClick/)
+  assert.match(chat, /event\.stopPropagation\(\); this\._onSessionCreateClick/)
+  assert.match(chat, /new CustomEvent\('session-switch'/)
+  assert.match(chat, /new CustomEvent\('session-create'/)
+})

package/translations/en.json

@@ -1,4 +1,10 @@
 {
+  "ai-assistant.session.new": "New conversation",
+  "ai-assistant.session.history": "Conversation history",
+  "ai-assistant.session.reset": "New conversation",
+  "ai-assistant.session.reset-help": "Keep previous history and your work, and start a new conversation. Previous messages are excluded from subsequent requests.",
+  "ai-assistant.session.loading": "Loading conversation history…",
+  "ai-assistant.session.retry": "Retry",
   "ai-assistant.label.ai": "operato",
   "ai-assistant.label.participant": "participant",
   "ai-assistant.label.create": "Create",

package/translations/ko.json

@@ -1,4 +1,10 @@
 {
+  "ai-assistant.session.new": "새 대화",
+  "ai-assistant.session.history": "대화 이력",
+  "ai-assistant.session.reset": "대화 리셋",
+  "ai-assistant.session.reset-help": "이전 이력과 작업 내용은 보존하고 새 대화를 시작합니다. 이전 대화는 다음 요청에 포함하지 않습니다.",
+  "ai-assistant.session.loading": "대화 이력을 불러오는 중…",
+  "ai-assistant.session.retry": "다시 시도",
   "ai-assistant.label.ai": "operato",
   "ai-assistant.label.participant": "참여자",
   "ai-assistant.label.create": "생성",