@things-factory/ai-assistant 10.1.212 → 10.1.213

package/client/utils/assistant-session-transport.ts

@@ -20,7 +20,7 @@ export const assistantSessionTransport: AssistantSessionTransport = {
        * Every readable conversation of this kind on the anchor, not only mine - the same scope the manager
        * shows by default (design/ai/shared-dock.md §2-6). Without a kind: every kind, as before.
        */
-      query: gql`query($type:String!,$id:String!,$kind:String){chatSessionInbox(anchorType:$type,anchorId:$id,kind:$kind,limit:100){id name kind visibility}}`,
+      query: gql`query($type:String!,$id:String!,$kind:String){chatSessionInbox(anchorType:$type,anchorId:$id,kind:$kind,limit:100){id name kind visibility participant}}`,
       variables: { type: target.anchorType, id: target.anchorId, kind: target.kind || null }, fetchPolicy: 'no-cache'
     })
     if (result.errors?.length) throw new Error(result.errors[0].message)

package/client/utils/invite-proposal-register.ts

@@ -0,0 +1,31 @@
+/*
+ * Pressing an invite card seats the person through the invite door, as the one who pressed (ADR-0073 decision 3).
+ * The card is ai-assistant's own tool (server: people/invite-tools.ts), so its handler is registered here, by the
+ * package that declared it - the dock knows no proposal kind (design/ai/shared-dock.md §4).
+ */
+import gql from 'graphql-tag'
+
+import { i18next } from '@operato/i18n'
+import { client } from '@operato/graphql'
+
+import { registerProposalHandler } from './assistant-proposals.js'
+import { inviteProposalHandler } from './invite-proposal.js'
+
+registerProposalHandler(
+  'proposeInvite',
+  inviteProposalHandler(
+    async (sessionId, userIds) => {
+      const result = await client.mutate({
+        mutation: gql`
+          mutation ($id: String!, $users: [String!]!) {
+            inviteToAISession(sessionId: $id, userIds: $users)
+          }
+        `,
+        variables: { id: sessionId, users: userIds }
+      })
+      if (result.errors?.length) throw new Error(result.errors[0].message)
+      return result.data?.inviteToAISession ?? []
+    },
+    (key, options) => String(i18next.t(key, options))
+  )
+)

package/client/utils/invite-proposal.test.ts

@@ -0,0 +1,40 @@
+import { inviteProposalHandler, invitedBy, isInviteProposal } from './invite-proposal'
+
+const card = (people: any[], extra: any = {}) => ({ tool: 'proposeInvite', kind: 'invite', people, ...extra })
+const kim = { userId: 'u-1', name: '정연희', department: 'Sales' }
+const lee = { userId: 'u-2', name: '정연희', department: 'Finance' }
+const t = (_key: string, options: any) => String(options.defaultValue).replace('{names}', options.names)
+const context = (sessionId?: string) => ({ sessionId, confirm: async () => true, notify: () => {} }) as any
+
+describe('the invite card', () => {
+  it('is the invite tool\'s card with someone on it', () => {
+    expect(isInviteProposal(card([kim]))).toBe(true)
+    expect(isInviteProposal(card([]))).toBe(false)
+    expect(isInviteProposal({ ...card([kim]), tool: 'proposeAction' })).toBe(false)
+  })
+
+  it('★ one person: pressing invites them; several: only the one picked - nothing is guessed', () => {
+    expect(invitedBy(card([kim]))).toEqual([kim])
+    expect(invitedBy(card([kim, lee]))).toEqual([])
+    expect(invitedBy(card([kim, lee], { chosen: 'u-2' }))).toEqual([lee])
+  })
+
+  it('★ pressing calls the invite door with the conversation and the person picked', async () => {
+    const calls: any[] = []
+    const handler = inviteProposalHandler(async (sessionId, userIds) => (calls.push([sessionId, userIds]), userIds), t)
+    expect(await handler(card([kim, lee], { chosen: 'u-2' }), context('s1'))).toMatchObject({ verdict: 'accepted', applied: 1, note: '정연희 joined this conversation and was told.' })
+    expect(calls).toEqual([['s1', ['u-2']]])
+  })
+
+  it('no pick, no conversation, or nobody seated - said, never accepted', async () => {
+    const handler = inviteProposalHandler(async (_s, userIds) => userIds, t)
+    expect(await handler(card([kim, lee]), context('s1'))).toEqual({ verdict: 'refused', errorCode: 'no-person-chosen' })
+    expect(await handler(card([kim]), context())).toEqual({ verdict: 'unavailable', errorCode: 'no-conversation' })
+    expect(await inviteProposalHandler(async () => [], t)(card([kim]), context('s1'))).toEqual({ verdict: 'refused', errorCode: 'already-here' })
+  })
+
+  it("the door's refusal is not swallowed - it is thrown to the dock, which reports it", async () => {
+    const handler = inviteProposalHandler(async () => { throw new Error('only the person who started this group conversation can bring people in.') }, t)
+    await expect(handler(card([kim]), context('s1'))).rejects.toThrow(/only the person who started/)
+  })
+})

package/client/utils/invite-proposal.ts

@@ -0,0 +1,54 @@
+/*
+ * The invite card (server: people/invite-tools.ts) - who it offers, and what pressing it does.
+ *
+ * Pressing is the person's act: the dock calls `inviteToAISession` with their own request, and the door decides
+ * whether they may seat anyone here (`maySeat`). The model's card seats nobody by itself. A card with several people
+ * of one name is pressed on one of them - the press carries `chosen`; nothing is guessed.
+ */
+import type { ProposalHandler } from './assistant-proposals.js'
+
+export interface InvitePerson {
+  userId: string
+  name: string
+  department?: string
+  position?: string
+}
+
+export function isInviteProposal(proposal: any): boolean {
+  return proposal?.kind === 'invite' && proposal?.tool === 'proposeInvite' && Array.isArray(proposal?.people) && proposal.people.length > 0
+}
+
+/** The people a press brings in: the one picked, or the only one on the card. */
+export function invitedBy(proposal: any): InvitePerson[] {
+  const people: InvitePerson[] = Array.isArray(proposal?.people) ? proposal.people.filter((one: any) => one?.userId) : []
+  if (proposal?.chosen) return people.filter(one => one.userId === proposal.chosen)
+  return people.length === 1 ? people : []
+}
+
+/** One line under a person's name - where they work. */
+export function personLine(person: InvitePerson): string {
+  return [person.department, person.position].filter(Boolean).join(' · ')
+}
+
+/**
+ * Presses the card through the invite door. `invite` is the door - `inviteToAISession(sessionId, userIds)`, answering the
+ * ids seated now; it throws the door's refusal, which the dock reports as `refused` with that message.
+ */
+export function inviteProposalHandler(
+  invite: (sessionId: string, userIds: string[]) => Promise<string[]>,
+  t: (key: string, options: Record<string, unknown>) => string
+): ProposalHandler {
+  return async (proposal, context) => {
+    const people = invitedBy(proposal)
+    if (!people.length) return { verdict: 'refused', errorCode: 'no-person-chosen' }
+    if (!context.sessionId) return { verdict: 'unavailable', errorCode: 'no-conversation' }
+    const seated = await invite(context.sessionId, people.map(one => one.userId))
+    if (!seated.length) return { verdict: 'refused', errorCode: 'already-here' }
+    const names = people.filter(one => seated.includes(one.userId)).map(one => one.name).join(', ')
+    return {
+      verdict: 'accepted',
+      applied: seated.length,
+      note: t('ai-assistant.people.invited', { names, defaultValue: '{names} joined this conversation and was told.' })
+    }
+  }
+}

package/dist-client/components/assistant-chat.d.ts

@@ -309,6 +309,15 @@ export declare class OxAssistantChat extends LitElement {
         text: string;
         attachments: ChatAttachment[];
     }): void;
+    /**
+     * A request made on the screen (「AI와 작업」, design/ai/shared-dock.md §2-11-1) - in this conversation, made now if it
+     * has none yet: the selection's note first, then the request, sent at once. What the person was writing is set aside
+     * while it goes and put back after, whatever happened. Says whether it was sent and, if not, why.
+     */
+    sendScreenRequest(text: string, note: string): Promise<{
+        sent: boolean;
+        reason?: string;
+    }>;
     private errorMessage?;
     /** C4 presence/roster — 세션 참여자 목록. lastSeenAt 으로 online 판정. */
     private participants;
@@ -560,6 +569,15 @@ export declare class OxAssistantChat extends LitElement {
      * 실행 결과는 호스트가 **대화에 기록**한다 — 누가 무엇을 실행했는지가 협의 이력에 남아야 한다.
      */
     private renderProposals;
+    /** A package's preview under its card - the element is the package's; it is handed the proposal and where it is. */
+    private renderProposalPreview;
+    /** One preview element per card, kept across renders so it does not read again on every keystroke. */
+    private proposalPreviews;
+    /**
+     * The invite card. Pressing it is the person's act - the dock calls the invite door with their request. With several
+     * people of one name each is a button with where they work; the press carries whom they picked.
+     */
+    private renderInviteCard;
     /** The screen card - which list, the conditions the screen does not take, and the way to open it. */
     private renderOpenPageCard;
     /** The AI 작업판 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */

package/dist-client/components/assistant-chat.js

@@ -5,6 +5,8 @@ import { rosterName } from './roster-identity';
 import { notify } from '@operato/layout';
 import './assistant-invite.js';
 import { TypingRoom } from '../utils/assistant-typing.js';
+import { isInviteProposal, personLine } from '../utils/invite-proposal.js';
+import { noteForDisplay } from '../utils/assistant-selection.js';
 /**
  * <ox-assistant-chat> — AI 도우미 채팅 컴포넌트 (Lit).
  *
@@ -63,6 +65,7 @@ import './entry-review.js';
 import { entryGroupOf, entryReadyCount, entryTitle, isChangeProposal, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js';
 import { isWorkspaceProposal, versionOfCard, workspaceAddress } from '../utils/workspace.js';
 import { isOpenPageProposal, openPageNote } from '../utils/open-page.js';
+import { proposalViewOf } from '../utils/assistant-proposals.js';
 function formatFileSize(bytes) {
     if (!bytes || bytes < 1024)
         return `${bytes || 0} B`;
@@ -279,6 +282,12 @@ const CHAT_TYPING_SUBSCRIPTION = gql `
     }
   }
 `;
+/* The selection a screen request carries, noted before the request (design/ai/shared-dock.md §2-11-1). */
+const APPEND_SESSION_NOTE_MUTATION = gql `
+  mutation AppendSessionNote($sessionId: String!, $content: String!) {
+    appendSessionNote(sessionId: $sessionId, content: $content)
+  }
+`;
 const TOUCH_PRESENCE_MUTATION = gql `
   mutation TouchPresence($sessionId: String!) {
     touchPresence(sessionId: $sessionId)
@@ -442,6 +451,8 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             this.foldNoticeDismissed = true;
             this.dispatchEvent(new CustomEvent('assistant-start-new-session', { bubbles: true, composed: true }));
         };
+        /** One preview element per card, kept across renders so it does not read again on every keystroke. */
+        this.proposalPreviews = new Map();
         /**
          * 실행은 호스트가 한다 — 이 컴포넌트는 도메인(트윈 명령 채널)을 모른다.
          * 확인 대화·명령 전송·결과 기록은 호스트의 몫이고, 여기서는 중복 클릭만 막는다.
@@ -715,6 +726,47 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         this.input = draft.text;
         this.attachments = draft.attachments;
     }
+    /**
+     * A request made on the screen (「AI와 작업」, design/ai/shared-dock.md §2-11-1) - in this conversation, made now if it
+     * has none yet: the selection's note first, then the request, sent at once. What the person was writing is set aside
+     * while it goes and put back after, whatever happened. Says whether it was sent and, if not, why.
+     */
+    async sendScreenRequest(text, note) {
+        if (this.busy)
+            return { sent: false, reason: i18next.t('ai-assistant.text.screen-request-busy', { defaultValue: 'an answer is still being written.' }) };
+        const kept = this.takeDraft();
+        try {
+            if (!this.sessionId && this.prepareSession) {
+                await this.prepareSession(id => {
+                    this.adoptingSession = true;
+                    this.sessionId = id;
+                });
+                await this.updateComplete;
+            }
+            if (!this.sessionId)
+                return { sent: false, reason: i18next.t('ai-assistant.text.screen-request-no-session', { defaultValue: 'this screen has no conversation to send to.' }) };
+            if (note) {
+                const noted = await client.mutate({ mutation: APPEND_SESSION_NOTE_MUTATION, variables: { sessionId: this.sessionId, content: note } });
+                if (noted.errors?.length)
+                    throw new Error(noted.errors[0].message);
+                await this.loadHistory();
+            }
+            this.errorMessage = undefined;
+            this.input = text;
+            await this.send();
+            return this.errorMessage ? { sent: false, reason: this.errorMessage } : { sent: true };
+        }
+        catch (error) {
+            return { sent: false, reason: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            /* The request is the screen's - it never stays in the box; the box gets back what the person had written. */
+            if (this.input.trim() === text.trim())
+                this.input = '';
+            if (kept && !this.input.trim() && !this.attachments.length)
+                this.restoreDraft(kept);
+        }
+    }
     /** 현재 로그인 사용자 email — 그룹챗에서 내 메시지 vs 타인 메시지 구분.
      *  email 을 쓰는 이유: /auth/profile 이 항상 내려주는 로그인 식별자이고(비어 있지 않다),
      *  내부 관리키(User.id)를 클라이언트 판정에 의존하지 않기 위함. */
@@ -1664,6 +1716,16 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
       --md-icon-size: 13px;
       color: inherit;
     }
+    /* The invite card's people - where each works, quieter than the name; a picked card greys every button. */
+    .proposal-choices .choice-chip .invite-where {
+      margin-left: 4px;
+      opacity: 0.7;
+      font-size: 0.92em;
+    }
+    .proposal-choices .choice-chip:disabled {
+      opacity: 0.5;
+      cursor: default;
+    }
 
     /* The entry card's way to the large review - a quiet action under its table, never a second run button. */
     .workspace-review {
@@ -2924,7 +2986,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                           class="sys-text"
                           title=${i18next.t('ai-assistant.text.toggle-system-note', { defaultValue: 'click to expand' })}
                           @click=${() => this.toggleSystemNote(idx)}
-                          >${content}</span
+                          >${noteForDisplay(content)}</span
                         >`
                                 : content}
                 ${line.attachments && line.attachments.length > 0
@@ -4022,7 +4084,12 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             if (isOpenPageProposal(p))
                 return this.renderOpenPageCard(p);
             const card = proposalCardState(key, { outcomes, requested, sentHere: this.sentProposals.has(key) });
+            /* An invite card: one person, one button; several of one name, one button each - the person picks (ADR-0073 decision 3). */
+            if (isInviteProposal(p))
+                return this.renderInviteCard(p, key, card.state);
             const entry = isEntryProposal(p);
+            /* A package's own card - its preview under the line, its words on the button (assistant-proposals.ts ProposalView). */
+            const view = entry ? undefined : proposalViewOf(p.tool);
             const replaced = entry && latestEntry?.get(entryGroupOf(p)) !== key && card.state === 'ready';
             const ready = entry ? entryReadyCount(p) : 0;
             const sent = card.state !== 'ready' || replaced || (entry && ready === 0);
@@ -4068,7 +4135,9 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                                     ? i18next.t('ai-assistant.entry.change', { defaultValue: 'change {count} records', count: ready })
                                     : i18next.t('ai-assistant.entry.enter', { defaultValue: 'enter {count} rows', count: ready })
                                 : i18next.t('ai-assistant.entry.nothing-to-enter', { defaultValue: 'nothing to enter' })
-                            : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
+                            : view?.runLabelKey || view?.runLabel
+                                ? i18next.t(view.runLabelKey ?? '', { defaultValue: view.runLabel ?? 'run' })
+                                : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
               ${ /*
@@ -4085,6 +4154,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
               ` : nothing}
             </div>
             ${entry ? html `<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
+            ${view?.previewTag ? this.renderProposalPreview(view.previewTag, p, key) : nothing}
             ${entry && this.sessionId && offersWorkspaceReview(p)
                 ? html `<button
                   class="workspace-review"
@@ -4112,6 +4182,51 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
       </div>
     `;
     }
+    /** A package's preview under its card - the element is the package's; it is handed the proposal and where it is. */
+    renderProposalPreview(tag, p, key) {
+        const element = this.proposalPreviews.get(key) ?? document.createElement(tag);
+        this.proposalPreviews.set(key, element);
+        element.proposal = p;
+        element.sessionId = this.sessionId;
+        element.proposalKey = key;
+        return html `${element}`;
+    }
+    /**
+     * The invite card. Pressing it is the person's act - the dock calls the invite door with their request. With several
+     * people of one name each is a button with where they work; the press carries whom they picked.
+     */
+    renderInviteCard(p, key, state) {
+        const people = p.people;
+        const sent = state !== 'ready';
+        const status = sent ? this.proposalStateText(key) : '';
+        return html `
+      <div class="proposal invite ${sent ? 'sent' : ''}">
+        <md-icon>${p.icon || 'person_add'}</md-icon>
+        <span class="pbody">
+          <span class="plabel">${p.label}</span>
+          ${p.reason ? html `<span class="preason">${p.reason}</span>` : nothing}
+          ${sent && people.length > 1 ? html `<span class="preason">${status}</span>` : nothing}
+        </span>
+        ${people.length === 1
+            ? html `<button class="run" ?disabled=${sent} @click=${() => this.executeProposal(p, key)}>
+              ${sent ? status : i18next.t('ai-assistant.button.invite', { defaultValue: 'Invite' })}
+            </button>`
+            : nothing}
+      </div>
+      ${people.length > 1
+            ? html `<div class="proposal-choices invite-people" role="group" aria-label=${p.label}>
+            ${people.map(person => html `<button
+                class="choice-chip"
+                ?disabled=${sent}
+                title=${personLine(person)}
+                @click=${() => this.executeProposal({ ...p, chosen: person.userId }, key)}>
+                <md-icon>person_add</md-icon>
+                <span>${person.name}${personLine(person) ? html ` <span class="invite-where">${personLine(person)}</span>` : nothing}</span>
+              </button>`)}
+          </div>`
+            : nothing}
+    `;
+    }
     /** The screen card - which list, the conditions the screen does not take, and the way to open it. */
     renderOpenPageCard(p) {
         const note = openPageNote(p, (key, options) => String(i18next.t(key, options)));