@humaan/payload-plugin-ai-assistant 0.0.0-stage → 0.1.0

package/dist/admin/toolSteps.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantUIMessage } from '../chat/messages.js';
+import type { PlanTargetKind } from '../types.js';
+export type EntityLabel = (slug: string, kind?: PlanTargetKind) => string;
+type Part = AssistantUIMessage['parts'][number];
+export interface ToolStep {
+    id: string;
+    label: string;
+    state: 'done' | 'failed' | 'running';
+}
+/** A line in the assistant's working steps, for every tool call except a successful plan, which shows as a card. */
+export declare function toolStep(part: Part, entityLabel: EntityLabel): ToolStep | undefined;
+export {};

package/dist/admin/toolSteps.js

@@ -0,0 +1,57 @@
+import { getToolName, isToolUIPart } from 'ai';
+/** A line in the assistant's working steps, for every tool call except a successful plan, which shows as a card. */ export function toolStep(part, entityLabel) {
+    if (!isToolUIPart(part)) {
+        return undefined;
+    }
+    const name = getToolName(part);
+    const input = part.input ?? {};
+    const state = part.state === 'output-error' ? 'failed' : part.state === 'output-available' ? 'done' : 'running';
+    if (name === 'submitPlan') {
+        if (part.state === 'output-available' && isRecord(part.output) && part.output.ok === true) {
+            return undefined;
+        }
+        const label = part.state === 'output-available' ? 'Corrected the plan' : 'Preparing the plan';
+        return {
+            id: part.toolCallId,
+            label,
+            state: part.state === 'output-available' ? 'done' : state
+        };
+    }
+    const output = part.state === 'output-available' && isRecord(part.output) ? part.output : {};
+    return {
+        id: part.toolCallId,
+        label: labelFor(name, input, output, entityLabel),
+        state
+    };
+}
+function labelFor(name, input, output, entityLabel) {
+    const slug = text(input.slug) || text(input.collection);
+    const kind = input.kind === 'global' ? 'global' : 'collection';
+    const entity = slug ? entityLabel(slug, kind) : '';
+    switch(name){
+        case 'describeTarget':
+            return `Read the ${entity} fields`;
+        case 'listTargets':
+            return 'Checked which collections can change';
+        case 'readDocument':
+            {
+                const title = text(output.label);
+                return kind === 'global' || !title ? `Read ${entity}` : `Read ${entity} “${title.slice(0, 60)}”`;
+            }
+        case 'searchDocuments':
+            {
+                const query = text(input.query).slice(0, 60);
+                return query ? `Searched ${entity} for “${query}”` : `Looked through ${entity}`;
+            }
+        default:
+            return name;
+    }
+}
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+//# sourceMappingURL=toolSteps.js.map

package/dist/admin/toolSteps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/admin/toolSteps.ts"],"sourcesContent":["import { getToolName, isToolUIPart } from 'ai'\n\nimport type { AssistantUIMessage } from '../chat/messages.js'\nimport type { PlanTargetKind } from '../types.js'\n\nexport type EntityLabel = (slug: string, kind?: PlanTargetKind) => string\n\ntype Part = AssistantUIMessage['parts'][number]\n\nexport interface ToolStep {\n  id: string\n  label: string\n  state: 'done' | 'failed' | 'running'\n}\n\n/** A line in the assistant's working steps, for every tool call except a successful plan, which shows as a card. */\nexport function toolStep(part: Part, entityLabel: EntityLabel): ToolStep | undefined {\n  if (!isToolUIPart(part)) {\n    return undefined\n  }\n  const name = getToolName(part)\n  const input = (part.input ?? {}) as Record<string, unknown>\n  const state =\n    part.state === 'output-error'\n      ? 'failed'\n      : part.state === 'output-available'\n        ? 'done'\n        : 'running'\n\n  if (name === 'submitPlan') {\n    if (part.state === 'output-available' && isRecord(part.output) && part.output.ok === true) {\n      return undefined\n    }\n    const label = part.state === 'output-available' ? 'Corrected the plan' : 'Preparing the plan'\n    return { id: part.toolCallId, label, state: part.state === 'output-available' ? 'done' : state }\n  }\n  const output = part.state === 'output-available' && isRecord(part.output) ? part.output : {}\n  return { id: part.toolCallId, label: labelFor(name, input, output, entityLabel), state }\n}\n\nfunction labelFor(\n  name: string,\n  input: Record<string, unknown>,\n  output: Record<string, unknown>,\n  entityLabel: EntityLabel,\n): string {\n  const slug = text(input.slug) || text(input.collection)\n  const kind = input.kind === 'global' ? 'global' : 'collection'\n  const entity = slug ? entityLabel(slug, kind) : ''\n  switch (name) {\n    case 'describeTarget':\n      return `Read the ${entity} fields`\n    case 'listTargets':\n      return 'Checked which collections can change'\n    case 'readDocument': {\n      const title = text(output.label)\n      return kind === 'global' || !title\n        ? `Read ${entity}`\n        : `Read ${entity} “${title.slice(0, 60)}”`\n    }\n    case 'searchDocuments': {\n      const query = text(input.query).slice(0, 60)\n      return query ? `Searched ${entity} for “${query}”` : `Looked through ${entity}`\n    }\n    default:\n      return name\n  }\n}\n\nfunction text(value: unknown): string {\n  return typeof value === 'string' ? value.trim() : ''\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)\n}\n"],"names":["getToolName","isToolUIPart","toolStep","part","entityLabel","undefined","name","input","state","isRecord","output","ok","label","id","toolCallId","labelFor","slug","text","collection","kind","entity","title","slice","query","value","trim","Boolean","Array","isArray"],"mappings":"AAAA,SAASA,WAAW,EAAEC,YAAY,QAAQ,KAAI;AAe9C,kHAAkH,GAClH,OAAO,SAASC,SAASC,IAAU,EAAEC,WAAwB;IAC3D,IAAI,CAACH,aAAaE,OAAO;QACvB,OAAOE;IACT;IACA,MAAMC,OAAON,YAAYG;IACzB,MAAMI,QAASJ,KAAKI,KAAK,IAAI,CAAC;IAC9B,MAAMC,QACJL,KAAKK,KAAK,KAAK,iBACX,WACAL,KAAKK,KAAK,KAAK,qBACb,SACA;IAER,IAAIF,SAAS,cAAc;QACzB,IAAIH,KAAKK,KAAK,KAAK,sBAAsBC,SAASN,KAAKO,MAAM,KAAKP,KAAKO,MAAM,CAACC,EAAE,KAAK,MAAM;YACzF,OAAON;QACT;QACA,MAAMO,QAAQT,KAAKK,KAAK,KAAK,qBAAqB,uBAAuB;QACzE,OAAO;YAAEK,IAAIV,KAAKW,UAAU;YAAEF;YAAOJ,OAAOL,KAAKK,KAAK,KAAK,qBAAqB,SAASA;QAAM;IACjG;IACA,MAAME,SAASP,KAAKK,KAAK,KAAK,sBAAsBC,SAASN,KAAKO,MAAM,IAAIP,KAAKO,MAAM,GAAG,CAAC;IAC3F,OAAO;QAAEG,IAAIV,KAAKW,UAAU;QAAEF,OAAOG,SAAST,MAAMC,OAAOG,QAAQN;QAAcI;IAAM;AACzF;AAEA,SAASO,SACPT,IAAY,EACZC,KAA8B,EAC9BG,MAA+B,EAC/BN,WAAwB;IAExB,MAAMY,OAAOC,KAAKV,MAAMS,IAAI,KAAKC,KAAKV,MAAMW,UAAU;IACtD,MAAMC,OAAOZ,MAAMY,IAAI,KAAK,WAAW,WAAW;IAClD,MAAMC,SAASJ,OAAOZ,YAAYY,MAAMG,QAAQ;IAChD,OAAQb;QACN,KAAK;YACH,OAAO,CAAC,SAAS,EAAEc,OAAO,OAAO,CAAC;QACpC,KAAK;YACH,OAAO;QACT,KAAK;YAAgB;gBACnB,MAAMC,QAAQJ,KAAKP,OAAOE,KAAK;gBAC/B,OAAOO,SAAS,YAAY,CAACE,QACzB,CAAC,KAAK,EAAED,QAAQ,GAChB,CAAC,KAAK,EAAEA,OAAO,EAAE,EAAEC,MAAMC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAC9C;QACA,KAAK;YAAmB;gBACtB,MAAMC,QAAQN,KAAKV,MAAMgB,KAAK,EAAED,KAAK,CAAC,GAAG;gBACzC,OAAOC,QAAQ,CAAC,SAAS,EAAEH,OAAO,MAAM,EAAEG,MAAM,CAAC,CAAC,GAAG,CAAC,eAAe,EAAEH,QAAQ;YACjF;QACA;YACE,OAAOd;IACX;AACF;AAEA,SAASW,KAAKO,KAAc;IAC1B,OAAO,OAAOA,UAAU,WAAWA,MAAMC,IAAI,KAAK;AACpD;AAEA,SAAShB,SAASe,KAAc;IAC9B,OAAOE,QAAQF,UAAU,OAAOA,UAAU,YAAY,CAACG,MAAMC,OAAO,CAACJ;AACvE"}

package/dist/admin/transport.d.ts

@@ -0,0 +1,24 @@
+import type { UIMessageChunk } from 'ai';
+import { DefaultChatTransport } from 'ai';
+import type { AssistantUIMessage } from '../chat/messages.js';
+import type { OpenDocument } from './openDocument.js';
+interface AssistantTransportOptions {
+    api: string;
+    openDocument: () => OpenDocument | undefined;
+}
+type SendOptions = Parameters<DefaultChatTransport<AssistantUIMessage>['sendMessages']>[0];
+/**
+ * Sends the new message as form data, with the open document and the ids of the conversation's attachments.
+ * The files themselves are already in storage, so requests stay small.
+ * The server keeps the history, so earlier messages are not sent again.
+ */
+export declare class AssistantTransport extends DefaultChatTransport<AssistantUIMessage> {
+    /** Ids of the conversation's stored attachments. */
+    private attachmentIds;
+    private readonly openDocument;
+    constructor({ api, openDocument }: AssistantTransportOptions);
+    reconnectToStream(): Promise<null>;
+    sendMessages({ chatId, messages, abortSignal, }: SendOptions): Promise<ReadableStream<UIMessageChunk>>;
+    setAttachmentIds(ids: readonly string[]): void;
+}
+export {};

package/dist/admin/transport.js

@@ -0,0 +1,75 @@
+import { DefaultChatTransport } from 'ai';
+/**
+ * Sends the new message as form data, with the open document and the ids of the conversation's attachments.
+ * The files themselves are already in storage, so requests stay small.
+ * The server keeps the history, so earlier messages are not sent again.
+ */ export class AssistantTransport extends DefaultChatTransport {
+    /** Ids of the conversation's stored attachments. */ attachmentIds = [];
+    openDocument;
+    constructor({ api, openDocument }){
+        super({
+            api,
+            credentials: 'include'
+        });
+        this.openDocument = openDocument;
+    }
+    reconnectToStream() {
+        return Promise.resolve(null);
+    }
+    async sendMessages({ chatId, messages, abortSignal }) {
+        const message = messages.at(-1);
+        if (!message || message.role !== 'user') {
+            throw new Error('There is no message to send.');
+        }
+        const body = new FormData();
+        body.set('chatId', chatId);
+        body.set('message', JSON.stringify({
+            id: message.id,
+            role: message.role,
+            parts: message.parts
+        }));
+        const open = this.openDocument();
+        if (open) {
+            body.set('context', JSON.stringify(open.context));
+            const data = readFormData(open);
+            if (data) {
+                body.set('contextData', data);
+            }
+        }
+        if (this.attachmentIds.length > 0) {
+            body.set('attachmentIds', JSON.stringify(this.attachmentIds));
+        }
+        const response = await fetch(this.api, {
+            method: 'POST',
+            body,
+            credentials: 'include',
+            signal: abortSignal
+        });
+        if (!response.ok) {
+            throw new Error(await errorMessage(response));
+        }
+        if (!response.body) {
+            throw new Error('The assistant could not be reached. Try again.');
+        }
+        return this.processResponseStream(response.body);
+    }
+    setAttachmentIds(ids) {
+        this.attachmentIds = ids;
+    }
+}
+function readFormData(open) {
+    try {
+        return JSON.stringify(open.getData());
+    } catch  {
+        return undefined;
+    }
+}
+async function errorMessage(response) {
+    const payload = await response.json().catch(()=>null);
+    if (payload && typeof payload === 'object' && 'message' in payload && typeof payload.message === 'string') {
+        return payload.message;
+    }
+    return 'The assistant could not be reached. Try again.';
+}
+
+//# sourceMappingURL=transport.js.map

package/dist/admin/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/admin/transport.ts"],"sourcesContent":["import type { UIMessageChunk } from 'ai'\n\nimport { DefaultChatTransport } from 'ai'\n\nimport type { AssistantUIMessage } from '../chat/messages.js'\nimport type { OpenDocument } from './openDocument.js'\n\ninterface AssistantTransportOptions {\n  api: string\n  openDocument: () => OpenDocument | undefined\n}\n\ntype SendOptions = Parameters<DefaultChatTransport<AssistantUIMessage>['sendMessages']>[0]\n\n/**\n * Sends the new message as form data, with the open document and the ids of the conversation's attachments.\n * The files themselves are already in storage, so requests stay small.\n * The server keeps the history, so earlier messages are not sent again.\n */\nexport class AssistantTransport extends DefaultChatTransport<AssistantUIMessage> {\n  /** Ids of the conversation's stored attachments. */\n  private attachmentIds: readonly string[] = []\n  private readonly openDocument: AssistantTransportOptions['openDocument']\n\n  constructor({ api, openDocument }: AssistantTransportOptions) {\n    super({ api, credentials: 'include' })\n    this.openDocument = openDocument\n  }\n\n  override reconnectToStream(): Promise<null> {\n    return Promise.resolve(null)\n  }\n\n  override async sendMessages({\n    chatId,\n    messages,\n    abortSignal,\n  }: SendOptions): Promise<ReadableStream<UIMessageChunk>> {\n    const message = messages.at(-1)\n    if (!message || message.role !== 'user') {\n      throw new Error('There is no message to send.')\n    }\n\n    const body = new FormData()\n    body.set('chatId', chatId)\n    body.set(\n      'message',\n      JSON.stringify({ id: message.id, role: message.role, parts: message.parts }),\n    )\n    const open = this.openDocument()\n    if (open) {\n      body.set('context', JSON.stringify(open.context))\n      const data = readFormData(open)\n      if (data) {\n        body.set('contextData', data)\n      }\n    }\n    if (this.attachmentIds.length > 0) {\n      body.set('attachmentIds', JSON.stringify(this.attachmentIds))\n    }\n\n    const response = await fetch(this.api, {\n      method: 'POST',\n      body,\n      credentials: 'include',\n      signal: abortSignal,\n    })\n    if (!response.ok) {\n      throw new Error(await errorMessage(response))\n    }\n    if (!response.body) {\n      throw new Error('The assistant could not be reached. Try again.')\n    }\n    return this.processResponseStream(response.body)\n  }\n\n  setAttachmentIds(ids: readonly string[]): void {\n    this.attachmentIds = ids\n  }\n}\n\nfunction readFormData(open: OpenDocument): string | undefined {\n  try {\n    return JSON.stringify(open.getData())\n  } catch {\n    return undefined\n  }\n}\n\nasync function errorMessage(response: Response): Promise<string> {\n  const payload: unknown = await response.json().catch(() => null)\n  if (\n    payload &&\n    typeof payload === 'object' &&\n    'message' in payload &&\n    typeof payload.message === 'string'\n  ) {\n    return payload.message\n  }\n  return 'The assistant could not be reached. Try again.'\n}\n"],"names":["DefaultChatTransport","AssistantTransport","attachmentIds","openDocument","api","credentials","reconnectToStream","Promise","resolve","sendMessages","chatId","messages","abortSignal","message","at","role","Error","body","FormData","set","JSON","stringify","id","parts","open","context","data","readFormData","length","response","fetch","method","signal","ok","errorMessage","processResponseStream","setAttachmentIds","ids","getData","undefined","payload","json","catch"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,KAAI;AAYzC;;;;CAIC,GACD,OAAO,MAAMC,2BAA2BD;IACtC,kDAAkD,GAClD,AAAQE,gBAAmC,EAAE,CAAA;IAC5BC,aAAuD;IAExE,YAAY,EAAEC,GAAG,EAAED,YAAY,EAA6B,CAAE;QAC5D,KAAK,CAAC;YAAEC;YAAKC,aAAa;QAAU;QACpC,IAAI,CAACF,YAAY,GAAGA;IACtB;IAESG,oBAAmC;QAC1C,OAAOC,QAAQC,OAAO,CAAC;IACzB;IAEA,MAAeC,aAAa,EAC1BC,MAAM,EACNC,QAAQ,EACRC,WAAW,EACC,EAA2C;QACvD,MAAMC,UAAUF,SAASG,EAAE,CAAC,CAAC;QAC7B,IAAI,CAACD,WAAWA,QAAQE,IAAI,KAAK,QAAQ;YACvC,MAAM,IAAIC,MAAM;QAClB;QAEA,MAAMC,OAAO,IAAIC;QACjBD,KAAKE,GAAG,CAAC,UAAUT;QACnBO,KAAKE,GAAG,CACN,WACAC,KAAKC,SAAS,CAAC;YAAEC,IAAIT,QAAQS,EAAE;YAAEP,MAAMF,QAAQE,IAAI;YAAEQ,OAAOV,QAAQU,KAAK;QAAC;QAE5E,MAAMC,OAAO,IAAI,CAACrB,YAAY;QAC9B,IAAIqB,MAAM;YACRP,KAAKE,GAAG,CAAC,WAAWC,KAAKC,SAAS,CAACG,KAAKC,OAAO;YAC/C,MAAMC,OAAOC,aAAaH;YAC1B,IAAIE,MAAM;gBACRT,KAAKE,GAAG,CAAC,eAAeO;YAC1B;QACF;QACA,IAAI,IAAI,CAACxB,aAAa,CAAC0B,MAAM,GAAG,GAAG;YACjCX,KAAKE,GAAG,CAAC,iBAAiBC,KAAKC,SAAS,CAAC,IAAI,CAACnB,aAAa;QAC7D;QAEA,MAAM2B,WAAW,MAAMC,MAAM,IAAI,CAAC1B,GAAG,EAAE;YACrC2B,QAAQ;YACRd;YACAZ,aAAa;YACb2B,QAAQpB;QACV;QACA,IAAI,CAACiB,SAASI,EAAE,EAAE;YAChB,MAAM,IAAIjB,MAAM,MAAMkB,aAAaL;QACrC;QACA,IAAI,CAACA,SAASZ,IAAI,EAAE;YAClB,MAAM,IAAID,MAAM;QAClB;QACA,OAAO,IAAI,CAACmB,qBAAqB,CAACN,SAASZ,IAAI;IACjD;IAEAmB,iBAAiBC,GAAsB,EAAQ;QAC7C,IAAI,CAACnC,aAAa,GAAGmC;IACvB;AACF;AAEA,SAASV,aAAaH,IAAkB;IACtC,IAAI;QACF,OAAOJ,KAAKC,SAAS,CAACG,KAAKc,OAAO;IACpC,EAAE,OAAM;QACN,OAAOC;IACT;AACF;AAEA,eAAeL,aAAaL,QAAkB;IAC5C,MAAMW,UAAmB,MAAMX,SAASY,IAAI,GAAGC,KAAK,CAAC,IAAM;IAC3D,IACEF,WACA,OAAOA,YAAY,YACnB,aAAaA,WACb,OAAOA,QAAQ3B,OAAO,KAAK,UAC3B;QACA,OAAO2B,QAAQ3B,OAAO;IACxB;IACA,OAAO;AACT"}

package/dist/admin/useAttachments.d.ts

@@ -0,0 +1,32 @@
+import type { UploadedAttachment } from './attachmentUpload.js';
+export interface ComposerAttachment {
+    error?: string;
+    /** Set once stored. */
+    id?: string;
+    key: string;
+    name: string;
+    size: number;
+    status: 'failed' | 'ready' | 'uploading';
+    type: string;
+}
+/**
+ * Files attached in a conversation. Each one uploads as soon as it is picked, so sending a message carries only ids.
+ * Attachments already sent stay with the conversation; ones removed before sending are deleted.
+ */
+export declare function useAttachments({ apiRoute, initial, }: {
+    apiRoute: string;
+    initial: readonly UploadedAttachment[];
+}): {
+    items: ComposerAttachment[];
+    add: (files: readonly File[]) => number;
+    remove: (key: string) => void;
+    /** Every stored attachment. The server ignores ids the conversation already has, so sending them all is safe. */
+    readyIds: string[];
+    unsent: ({
+        id: string;
+    } & ComposerAttachment)[];
+    sentIds: ReadonlySet<string>;
+    uploading: boolean;
+    full: boolean;
+    markSent: (ids: readonly string[]) => void;
+};

package/dist/admin/useAttachments.js

@@ -0,0 +1,91 @@
+'use client';
+import { useUploadHandlers } from '@payloadcms/ui';
+import { generateId } from 'ai';
+import { useState } from 'react';
+import { attachmentProblem } from '../attachments/rules.js';
+import { aiAssistantAttachmentSlug, maxFiles } from '../constants.js';
+import { removeAttachment, uploadAttachment } from './attachmentUpload.js';
+/**
+ * Files attached in a conversation. Each one uploads as soon as it is picked, so sending a message carries only ids.
+ * Attachments already sent stay with the conversation; ones removed before sending are deleted.
+ */ export function useAttachments({ apiRoute, initial }) {
+    const { getUploadHandler } = useUploadHandlers();
+    const [items, setItems] = useState(()=>initial.map((attachment)=>({
+                key: attachment.id,
+                ...attachment,
+                status: 'ready'
+            })));
+    const [sentIds, setSentIds] = useState(()=>new Set(initial.map((attachment)=>attachment.id)));
+    const update = (key, change)=>setItems((current)=>current.map((item)=>item.key === key ? {
+                    ...item,
+                    ...change
+                } : item));
+    /** Starts uploading the picked files. Returns how many were left out because the conversation is full. */ const add = (files)=>{
+        const room = Math.max(0, maxFiles - items.filter((item)=>item.status !== 'failed').length);
+        const accepted = files.slice(0, room);
+        const handler = getUploadHandler({
+            collectionSlug: aiAssistantAttachmentSlug
+        });
+        const added = accepted.map((file)=>{
+            const problem = attachmentProblem({
+                name: file.name,
+                type: file.type,
+                size: file.size
+            });
+            const item = {
+                key: generateId(),
+                name: file.name,
+                size: file.size,
+                type: file.type,
+                status: problem ? 'failed' : 'uploading',
+                ...problem ? {
+                    error: problem
+                } : {}
+            };
+            if (!problem) {
+                uploadAttachment({
+                    apiRoute,
+                    file,
+                    handler
+                }).then((stored)=>update(item.key, {
+                        ...stored,
+                        status: 'ready'
+                    })).catch((error)=>update(item.key, {
+                        status: 'failed',
+                        error: error instanceof Error && error.message ? error.message : `${file.name} could not be uploaded.`
+                    }));
+            }
+            return item;
+        });
+        setItems((current)=>[
+                ...current,
+                ...added
+            ]);
+        return files.length - accepted.length;
+    };
+    const remove = (key)=>{
+        const item = items.find((entry)=>entry.key === key);
+        setItems((current)=>current.filter((entry)=>entry.key !== key));
+        if (item?.id && !sentIds.has(item.id)) {
+            void removeAttachment(apiRoute, item.id);
+        }
+    };
+    const ready = items.filter((item)=>item.status === 'ready' && Boolean(item.id));
+    const unsent = ready.filter((item)=>!sentIds.has(item.id));
+    return {
+        items,
+        add,
+        remove,
+        /** Every stored attachment. The server ignores ids the conversation already has, so sending them all is safe. */ readyIds: ready.map((item)=>item.id),
+        unsent,
+        sentIds,
+        uploading: items.some((item)=>item.status === 'uploading'),
+        full: items.filter((item)=>item.status !== 'failed').length >= maxFiles,
+        markSent: (ids)=>setSentIds((current)=>new Set([
+                    ...current,
+                    ...ids
+                ]))
+    };
+}
+
+//# sourceMappingURL=useAttachments.js.map

package/dist/admin/useAttachments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/admin/useAttachments.ts"],"sourcesContent":["'use client'\n\nimport type { UploadCollectionSlug } from 'payload'\n\nimport { useUploadHandlers } from '@payloadcms/ui'\nimport { generateId } from 'ai'\nimport { useState } from 'react'\n\nimport type { UploadedAttachment } from './attachmentUpload.js'\n\nimport { attachmentProblem } from '../attachments/rules.js'\nimport { aiAssistantAttachmentSlug, maxFiles } from '../constants.js'\nimport { removeAttachment, uploadAttachment } from './attachmentUpload.js'\n\nexport interface ComposerAttachment {\n  error?: string\n  /** Set once stored. */\n  id?: string\n  key: string\n  name: string\n  size: number\n  status: 'failed' | 'ready' | 'uploading'\n  type: string\n}\n\n/**\n * Files attached in a conversation. Each one uploads as soon as it is picked, so sending a message carries only ids.\n * Attachments already sent stay with the conversation; ones removed before sending are deleted.\n */\nexport function useAttachments({\n  apiRoute,\n  initial,\n}: {\n  apiRoute: string\n  initial: readonly UploadedAttachment[]\n}) {\n  const { getUploadHandler } = useUploadHandlers()\n  const [items, setItems] = useState<ComposerAttachment[]>(() =>\n    initial.map((attachment) => ({ key: attachment.id, ...attachment, status: 'ready' })),\n  )\n  const [sentIds, setSentIds] = useState<ReadonlySet<string>>(\n    () => new Set(initial.map((attachment) => attachment.id)),\n  )\n\n  const update = (key: string, change: Partial<ComposerAttachment>) =>\n    setItems((current) => current.map((item) => (item.key === key ? { ...item, ...change } : item)))\n\n  /** Starts uploading the picked files. Returns how many were left out because the conversation is full. */\n  const add = (files: readonly File[]): number => {\n    const room = Math.max(0, maxFiles - items.filter((item) => item.status !== 'failed').length)\n    const accepted = files.slice(0, room)\n    const handler = getUploadHandler({\n      collectionSlug: aiAssistantAttachmentSlug as UploadCollectionSlug,\n    })\n\n    const added = accepted.map((file) => {\n      const problem = attachmentProblem({ name: file.name, type: file.type, size: file.size })\n      const item: ComposerAttachment = {\n        key: generateId(),\n        name: file.name,\n        size: file.size,\n        type: file.type,\n        status: problem ? 'failed' : 'uploading',\n        ...(problem ? { error: problem } : {}),\n      }\n      if (!problem) {\n        uploadAttachment({ apiRoute, file, handler })\n          .then((stored) => update(item.key, { ...stored, status: 'ready' }))\n          .catch((error: unknown) =>\n            update(item.key, {\n              status: 'failed',\n              error:\n                error instanceof Error && error.message\n                  ? error.message\n                  : `${file.name} could not be uploaded.`,\n            }),\n          )\n      }\n      return item\n    })\n    setItems((current) => [...current, ...added])\n    return files.length - accepted.length\n  }\n\n  const remove = (key: string) => {\n    const item = items.find((entry) => entry.key === key)\n    setItems((current) => current.filter((entry) => entry.key !== key))\n    if (item?.id && !sentIds.has(item.id)) {\n      void removeAttachment(apiRoute, item.id)\n    }\n  }\n\n  const ready = items.filter(\n    (item): item is { id: string } & ComposerAttachment =>\n      item.status === 'ready' && Boolean(item.id),\n  )\n  const unsent = ready.filter((item) => !sentIds.has(item.id))\n\n  return {\n    items,\n    add,\n    remove,\n    /** Every stored attachment. The server ignores ids the conversation already has, so sending them all is safe. */\n    readyIds: ready.map((item) => item.id),\n    unsent,\n    sentIds,\n    uploading: items.some((item) => item.status === 'uploading'),\n    full: items.filter((item) => item.status !== 'failed').length >= maxFiles,\n    markSent: (ids: readonly string[]) => setSentIds((current) => new Set([...current, ...ids])),\n  }\n}\n"],"names":["useUploadHandlers","generateId","useState","attachmentProblem","aiAssistantAttachmentSlug","maxFiles","removeAttachment","uploadAttachment","useAttachments","apiRoute","initial","getUploadHandler","items","setItems","map","attachment","key","id","status","sentIds","setSentIds","Set","update","change","current","item","add","files","room","Math","max","filter","length","accepted","slice","handler","collectionSlug","added","file","problem","name","type","size","error","then","stored","catch","Error","message","remove","find","entry","has","ready","Boolean","unsent","readyIds","uploading","some","full","markSent","ids"],"mappings":"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"}

package/dist/admin/useEntityLabel.d.ts

@@ -0,0 +1,3 @@
+import type { PlanTargetKind } from '../types.js';
+/** Turns a collection or global slug into the singular label editors see in the admin, such as "Page". */
+export declare function useEntityLabel(): (slug: string, kind?: PlanTargetKind) => string;

package/dist/admin/useEntityLabel.js

@@ -0,0 +1,23 @@
+import { useConfig } from '@payloadcms/ui';
+/** Turns a collection or global slug into the singular label editors see in the admin, such as "Page". */ export function useEntityLabel() {
+    const { config } = useConfig();
+    return (slug, kind = 'collection')=>{
+        if (kind === 'global') {
+            return labelText(config.globals.find((global)=>global.slug === slug)?.label) ?? slug;
+        }
+        const labels = config.collections.find((collection)=>collection.slug === slug)?.labels;
+        return labelText(labels?.singular) ?? slug;
+    };
+}
+function labelText(label) {
+    if (typeof label === 'string' && label) {
+        return label;
+    }
+    if (label && typeof label === 'object') {
+        const first = Object.values(label).find((value)=>typeof value === 'string' && value);
+        return typeof first === 'string' ? first : undefined;
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=useEntityLabel.js.map

package/dist/admin/useEntityLabel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/admin/useEntityLabel.ts"],"sourcesContent":["import { useConfig } from '@payloadcms/ui'\n\nimport type { PlanTargetKind } from '../types.js'\n\n/** Turns a collection or global slug into the singular label editors see in the admin, such as \"Page\". */\nexport function useEntityLabel(): (slug: string, kind?: PlanTargetKind) => string {\n  const { config } = useConfig()\n  return (slug, kind = 'collection') => {\n    if (kind === 'global') {\n      return labelText(config.globals.find((global) => global.slug === slug)?.label) ?? slug\n    }\n    const labels = config.collections.find((collection) => collection.slug === slug)?.labels\n    return labelText(labels?.singular) ?? slug\n  }\n}\n\nfunction labelText(label: unknown): string | undefined {\n  if (typeof label === 'string' && label) {\n    return label\n  }\n  if (label && typeof label === 'object') {\n    const first = Object.values(label).find((value) => typeof value === 'string' && value)\n    return typeof first === 'string' ? first : undefined\n  }\n  return undefined\n}\n"],"names":["useConfig","useEntityLabel","config","slug","kind","labelText","globals","find","global","label","labels","collections","collection","singular","first","Object","values","value","undefined"],"mappings":"AAAA,SAASA,SAAS,QAAQ,iBAAgB;AAI1C,wGAAwG,GACxG,OAAO,SAASC;IACd,MAAM,EAAEC,MAAM,EAAE,GAAGF;IACnB,OAAO,CAACG,MAAMC,OAAO,YAAY;QAC/B,IAAIA,SAAS,UAAU;YACrB,OAAOC,UAAUH,OAAOI,OAAO,CAACC,IAAI,CAAC,CAACC,SAAWA,OAAOL,IAAI,KAAKA,OAAOM,UAAUN;QACpF;QACA,MAAMO,SAASR,OAAOS,WAAW,CAACJ,IAAI,CAAC,CAACK,aAAeA,WAAWT,IAAI,KAAKA,OAAOO;QAClF,OAAOL,UAAUK,QAAQG,aAAaV;IACxC;AACF;AAEA,SAASE,UAAUI,KAAc;IAC/B,IAAI,OAAOA,UAAU,YAAYA,OAAO;QACtC,OAAOA;IACT;IACA,IAAIA,SAAS,OAAOA,UAAU,UAAU;QACtC,MAAMK,QAAQC,OAAOC,MAAM,CAACP,OAAOF,IAAI,CAAC,CAACU,QAAU,OAAOA,UAAU,YAAYA;QAChF,OAAO,OAAOH,UAAU,WAAWA,QAAQI;IAC7C;IACA,OAAOA;AACT"}

package/dist/attachments/collection.d.ts

@@ -0,0 +1,15 @@
+import type { CollectionConfig, CollectionSlug } from 'payload';
+import type { AssistantSettings } from '../types.js';
+/**
+ * The upload collection for files attached in a conversation. Add it to the Payload config's `collections`
+ * and to your storage adapter's collections, with client uploads on, so large files go straight to storage
+ * instead of through a server request. Keep its files private.
+ *
+ * The plugin adds the owner field, access control, and file checks, so this only needs the slug and upload settings.
+ */
+export declare function aiAssistantAttachmentsCollection(overrides?: Partial<CollectionConfig>): CollectionConfig;
+/**
+ * Applied by the plugin to the project's attachments collection, after storage adapters have added theirs.
+ * Each attachment belongs to the editor who uploaded it. Only they can read or delete it, and nobody can edit it.
+ */
+export declare function withAttachmentRules(collection: CollectionConfig, usersSlug: CollectionSlug, fallback: AssistantSettings): CollectionConfig;

package/dist/attachments/collection.js

@@ -0,0 +1,90 @@
+import { APIError } from 'payload';
+import { assistantAccess, ownerAccess } from '../collectionAccess.js';
+import { aiAssistantAttachmentSlug } from '../constants.js';
+import { userIdOf } from '../settings.js';
+import { attachmentProblem } from './rules.js';
+/**
+ * The upload collection for files attached in a conversation. Add it to the Payload config's `collections`
+ * and to your storage adapter's collections, with client uploads on, so large files go straight to storage
+ * instead of through a server request. Keep its files private.
+ *
+ * The plugin adds the owner field, access control, and file checks, so this only needs the slug and upload settings.
+ */ export function aiAssistantAttachmentsCollection(overrides = {}) {
+    return {
+        slug: aiAssistantAttachmentSlug,
+        labels: {
+            singular: 'Humaan AI attachment',
+            plural: 'Humaan AI attachments'
+        },
+        admin: {
+            hidden: true
+        },
+        upload: true,
+        fields: [],
+        ...overrides
+    };
+}
+/**
+ * Applied by the plugin to the project's attachments collection, after storage adapters have added theirs.
+ * Each attachment belongs to the editor who uploaded it. Only they can read or delete it, and nobody can edit it.
+ */ export function withAttachmentRules(collection, usersSlug, fallback) {
+    const owned = ownerAccess(fallback);
+    return {
+        ...collection,
+        admin: {
+            ...collection.admin,
+            hidden: true
+        },
+        access: {
+            ...collection.access,
+            create: assistantAccess(fallback),
+            read: owned,
+            update: ()=>false,
+            delete: owned
+        },
+        fields: [
+            ...collection.fields,
+            {
+                name: 'owner',
+                type: 'relationship',
+                relationTo: usersSlug,
+                index: true,
+                admin: {
+                    readOnly: true
+                }
+            }
+        ],
+        hooks: {
+            ...collection.hooks,
+            beforeChange: [
+                ...collection.hooks?.beforeChange ?? [],
+                checkAttachment
+            ]
+        }
+    };
+}
+/**
+ * Sets the owner from the session and refuses programs and oversized files. With client uploads the file is
+ * already in storage by now, so the panel checks the same rules before it uploads.
+ */ const checkAttachment = ({ data, operation, req })=>{
+    if (operation !== 'create') {
+        return data;
+    }
+    const name = typeof data.filename === 'string' ? data.filename : '';
+    const type = typeof data.mimeType === 'string' ? data.mimeType : '';
+    const size = typeof data.filesize === 'number' ? data.filesize : 0;
+    const problem = attachmentProblem({
+        name,
+        type,
+        size
+    });
+    if (problem) {
+        throw new APIError(problem, 400, undefined, true);
+    }
+    return {
+        ...data,
+        owner: userIdOf(req.user)
+    };
+};
+
+//# sourceMappingURL=collection.js.map

package/dist/attachments/collection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/attachments/collection.ts"],"sourcesContent":["import type { CollectionBeforeChangeHook, CollectionConfig, CollectionSlug } from 'payload'\n\nimport { APIError } from 'payload'\n\nimport type { AssistantSettings } from '../types.js'\n\nimport { assistantAccess, ownerAccess } from '../collectionAccess.js'\nimport { aiAssistantAttachmentSlug } from '../constants.js'\nimport { userIdOf } from '../settings.js'\nimport { attachmentProblem } from './rules.js'\n\n/**\n * The upload collection for files attached in a conversation. Add it to the Payload config's `collections`\n * and to your storage adapter's collections, with client uploads on, so large files go straight to storage\n * instead of through a server request. Keep its files private.\n *\n * The plugin adds the owner field, access control, and file checks, so this only needs the slug and upload settings.\n */\nexport function aiAssistantAttachmentsCollection(\n  overrides: Partial<CollectionConfig> = {},\n): CollectionConfig {\n  return {\n    slug: aiAssistantAttachmentSlug,\n    labels: { singular: 'Humaan AI attachment', plural: 'Humaan AI attachments' },\n    admin: { hidden: true },\n    upload: true,\n    fields: [],\n    ...overrides,\n  }\n}\n\n/**\n * Applied by the plugin to the project's attachments collection, after storage adapters have added theirs.\n * Each attachment belongs to the editor who uploaded it. Only they can read or delete it, and nobody can edit it.\n */\nexport function withAttachmentRules(\n  collection: CollectionConfig,\n  usersSlug: CollectionSlug,\n  fallback: AssistantSettings,\n): CollectionConfig {\n  const owned = ownerAccess(fallback)\n  return {\n    ...collection,\n    admin: { ...collection.admin, hidden: true },\n    access: {\n      ...collection.access,\n      create: assistantAccess(fallback),\n      read: owned,\n      update: () => false,\n      delete: owned,\n    },\n    fields: [\n      ...collection.fields,\n      {\n        name: 'owner',\n        type: 'relationship',\n        relationTo: usersSlug,\n        index: true,\n        admin: { readOnly: true },\n      },\n    ],\n    hooks: {\n      ...collection.hooks,\n      beforeChange: [...(collection.hooks?.beforeChange ?? []), checkAttachment],\n    },\n  }\n}\n\n/**\n * Sets the owner from the session and refuses programs and oversized files. With client uploads the file is\n * already in storage by now, so the panel checks the same rules before it uploads.\n */\nconst checkAttachment: CollectionBeforeChangeHook = ({ data, operation, req }) => {\n  if (operation !== 'create') {\n    return data\n  }\n  const name = typeof data.filename === 'string' ? data.filename : ''\n  const type = typeof data.mimeType === 'string' ? data.mimeType : ''\n  const size = typeof data.filesize === 'number' ? data.filesize : 0\n  const problem = attachmentProblem({ name, type, size })\n  if (problem) {\n    throw new APIError(problem, 400, undefined, true)\n  }\n  return { ...data, owner: userIdOf(req.user) }\n}\n"],"names":["APIError","assistantAccess","ownerAccess","aiAssistantAttachmentSlug","userIdOf","attachmentProblem","aiAssistantAttachmentsCollection","overrides","slug","labels","singular","plural","admin","hidden","upload","fields","withAttachmentRules","collection","usersSlug","fallback","owned","access","create","read","update","delete","name","type","relationTo","index","readOnly","hooks","beforeChange","checkAttachment","data","operation","req","filename","mimeType","size","filesize","problem","undefined","owner","user"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,UAAS;AAIlC,SAASC,eAAe,EAAEC,WAAW,QAAQ,yBAAwB;AACrE,SAASC,yBAAyB,QAAQ,kBAAiB;AAC3D,SAASC,QAAQ,QAAQ,iBAAgB;AACzC,SAASC,iBAAiB,QAAQ,aAAY;AAE9C;;;;;;CAMC,GACD,OAAO,SAASC,iCACdC,YAAuC,CAAC,CAAC;IAEzC,OAAO;QACLC,MAAML;QACNM,QAAQ;YAAEC,UAAU;YAAwBC,QAAQ;QAAwB;QAC5EC,OAAO;YAAEC,QAAQ;QAAK;QACtBC,QAAQ;QACRC,QAAQ,EAAE;QACV,GAAGR,SAAS;IACd;AACF;AAEA;;;CAGC,GACD,OAAO,SAASS,oBACdC,UAA4B,EAC5BC,SAAyB,EACzBC,QAA2B;IAE3B,MAAMC,QAAQlB,YAAYiB;IAC1B,OAAO;QACL,GAAGF,UAAU;QACbL,OAAO;YAAE,GAAGK,WAAWL,KAAK;YAAEC,QAAQ;QAAK;QAC3CQ,QAAQ;YACN,GAAGJ,WAAWI,MAAM;YACpBC,QAAQrB,gBAAgBkB;YACxBI,MAAMH;YACNI,QAAQ,IAAM;YACdC,QAAQL;QACV;QACAL,QAAQ;eACHE,WAAWF,MAAM;YACpB;gBACEW,MAAM;gBACNC,MAAM;gBACNC,YAAYV;gBACZW,OAAO;gBACPjB,OAAO;oBAAEkB,UAAU;gBAAK;YAC1B;SACD;QACDC,OAAO;YACL,GAAGd,WAAWc,KAAK;YACnBC,cAAc;mBAAKf,WAAWc,KAAK,EAAEC,gBAAgB,EAAE;gBAAGC;aAAgB;QAC5E;IACF;AACF;AAEA;;;CAGC,GACD,MAAMA,kBAA8C,CAAC,EAAEC,IAAI,EAAEC,SAAS,EAAEC,GAAG,EAAE;IAC3E,IAAID,cAAc,UAAU;QAC1B,OAAOD;IACT;IACA,MAAMR,OAAO,OAAOQ,KAAKG,QAAQ,KAAK,WAAWH,KAAKG,QAAQ,GAAG;IACjE,MAAMV,OAAO,OAAOO,KAAKI,QAAQ,KAAK,WAAWJ,KAAKI,QAAQ,GAAG;IACjE,MAAMC,OAAO,OAAOL,KAAKM,QAAQ,KAAK,WAAWN,KAAKM,QAAQ,GAAG;IACjE,MAAMC,UAAUpC,kBAAkB;QAAEqB;QAAMC;QAAMY;IAAK;IACrD,IAAIE,SAAS;QACX,MAAM,IAAIzC,SAASyC,SAAS,KAAKC,WAAW;IAC9C;IACA,OAAO;QAAE,GAAGR,IAAI;QAAES,OAAOvC,SAASgC,IAAIQ,IAAI;IAAE;AAC9C"}

package/dist/attachments/conversation.d.ts

@@ -0,0 +1,25 @@
+import type { FileUIPart } from 'ai';
+import type { PayloadRequest, SanitizedConfig } from 'payload';
+import type { ThreadFile } from '../chat/threads.js';
+import type { IncomingFile } from '../plan/parsePlan.js';
+import type { AttachmentRecord } from './store.js';
+export type AttachmentAddition = {
+    added: ThreadFile[];
+    files: ThreadFile[];
+    ok: true;
+} | {
+    message: string;
+    ok: false;
+};
+/**
+ * Adds a message's new attachments to the conversation's list. `found` is what the attachments collection returned
+ * for the requested ids, with the editor's access, so an id that is missing is someone else's or no longer exists.
+ */
+export declare function addAttachments(known: readonly ThreadFile[], requested: readonly string[], found: readonly AttachmentRecord[]): AttachmentAddition;
+/**
+ * The conversation's readable attachments, with where a plan would save each one. Only upload collections the
+ * assistant may change are considered. A file none of them accepts can still be read, but not saved.
+ */
+export declare function conversationFiles(config: SanitizedConfig, files: readonly ThreadFile[]): IncomingFile[];
+/** Images and PDFs, read from storage so the model can see them. A file that cannot be read is described by name only. */
+export declare function modelFileParts(req: PayloadRequest, files: readonly IncomingFile[]): Promise<Map<number, FileUIPart>>;

package/dist/attachments/conversation.js

@@ -0,0 +1,105 @@
+import { maxFiles } from '../constants.js';
+import { uploadTargets } from '../plan/catalogue.js';
+import { chooseUploadCollection, kindFromMime } from '../uploads/routeAsset.js';
+import { readAttachment } from './store.js';
+/**
+ * Adds a message's new attachments to the conversation's list. `found` is what the attachments collection returned
+ * for the requested ids, with the editor's access, so an id that is missing is someone else's or no longer exists.
+ */ export function addAttachments(known, requested, found) {
+    const knownIds = new Set(known.flatMap((file)=>file.id ? [
+            file.id
+        ] : []));
+    const newIds = [
+        ...new Set(requested)
+    ].filter((id)=>!knownIds.has(id));
+    if (known.length + newIds.length > maxFiles) {
+        return {
+            ok: false,
+            message: `A conversation can have up to ${maxFiles} files. Start a new conversation for more.`
+        };
+    }
+    const byId = new Map(found.map((record)=>[
+            record.id,
+            record
+        ]));
+    const added = [];
+    for (const id of newIds){
+        const record = byId.get(id);
+        if (!record) {
+            return {
+                ok: false,
+                message: 'An attached file could not be found. Attach it again.'
+            };
+        }
+        added.push({
+            id,
+            name: record.name,
+            size: record.size,
+            type: record.type
+        });
+    }
+    return {
+        ok: true,
+        files: [
+            ...known,
+            ...added
+        ],
+        added
+    };
+}
+/**
+ * The conversation's readable attachments, with where a plan would save each one. Only upload collections the
+ * assistant may change are considered. A file none of them accepts can still be read, but not saved.
+ */ export function conversationFiles(config, files) {
+    const targets = uploadTargets(config).map((target)=>{
+        const collection = config.collections.find((item)=>item.slug === target.slug);
+        const drafts = Boolean(collection?.versions && typeof collection.versions === 'object' && collection.versions.drafts);
+        return {
+            ...target,
+            drafts
+        };
+    });
+    return files.flatMap((file, index)=>{
+        if (!file.id) {
+            return [];
+        }
+        const choice = chooseUploadCollection(file, targets);
+        const target = 'error' in choice ? undefined : targets.find((item)=>item.slug === choice.slug);
+        return [
+            {
+                index,
+                attachmentId: file.id,
+                name: file.name,
+                size: file.size,
+                type: 'error' in choice ? file.type : choice.mime,
+                collection: target?.slug ?? '',
+                kind: 'error' in choice ? kindFromMime(file.type) : choice.kind,
+                savesImmediately: !target?.drafts
+            }
+        ];
+    });
+}
+/** Images and PDFs, read from storage so the model can see them. A file that cannot be read is described by name only. */ export async function modelFileParts(req, files) {
+    const readable = files.filter((file)=>file.kind === 'image' || file.type === 'application/pdf');
+    const parts = new Map();
+    await Promise.all(readable.map(async (file)=>{
+        try {
+            // The type the bytes arrived as, in case storage converted the format.
+            const { data, type } = await readAttachment(req, file.attachmentId);
+            parts.set(file.index, {
+                type: 'file',
+                mediaType: type,
+                filename: file.name,
+                url: `data:${type};base64,${data.toString('base64')}`
+            });
+        } catch (error) {
+            req.payload.logger.warn({
+                err: error,
+                attachment: file.attachmentId
+            }, 'Humaan AI could not read an attachment');
+        }
+    }));
+    return parts;
+}
+
+//# sourceMappingURL=conversation.js.map