@frontera-sdk/chat 1.52.45 → 1.52.46

package/src/chat-errors.ts

@@ -0,0 +1,43 @@
+import { FronteraError } from '@frontera-sdk/core/errors'
+
+/**
+ * The error codes a chat integration meets, and what each means for the
+ * person chatting (Forge improvement plan L4: the codes were found by reading
+ * the package source). Every SDK call throws `FronteraError`; branch on its
+ * `code`. The service can add codes, so treat one not listed here as
+ * `INTERNAL_ERROR`.
+ */
+export const CHAT_ERROR_CODES = {
+  UNAUTHORIZED: 'The key or token was not accepted: it is disabled, removed, mistyped or expired. Mint a new token; if that fails too, check the key.',
+  FORBIDDEN: 'The credential may not do this: the page is not on the key’s allowed websites, or a visitor asked for something a public chat cannot do.',
+  NOT_FOUND: 'The conversation or run is not this credential’s, or no longer exists.',
+  VALIDATION_ERROR: 'The request was malformed, for example an empty message or more than five messages.',
+  RATE_LIMITED: 'Too many messages or new chats in a short time. Wait the number of seconds the message names, then try again.',
+  QUOTA_EXCEEDED: 'The organization’s usage limit is reached. An administrator raises it.',
+  SERVICE_UNAVAILABLE: 'The platform can’t take the request right now. Try again shortly.',
+  INTERNAL_ERROR: 'Something failed on the platform. Try again; if it keeps failing, the message names what to report.',
+  PROTOCOL_ERROR: 'The response wasn’t a chat stream: the API origin is likely wrong, or a proxy changed the response.',
+  FORBIDDEN_LOCAL: 'Your own `authorizeConversation` callback denied access to the conversation.',
+  CONFIG_MISSING: 'The client has no API origin or credential.',
+} as const
+
+export type ChatErrorCode = keyof typeof CHAT_ERROR_CODES
+
+/** The code of any thrown value, `INTERNAL_ERROR` for one that isn't a `FronteraError` (a network failure included). */
+export function chatErrorCode(err: unknown): ChatErrorCode {
+  const code = err instanceof FronteraError ? err.code : null
+  return code && code in CHAT_ERROR_CODES ? (code as ChatErrorCode) : 'INTERNAL_ERROR'
+}
+
+/**
+ * What to show a website visitor for an error: the platform's own message for
+ * a limit (it names the wait), plain words otherwise. Never the raw response.
+ */
+export function visitorErrorWords(err: unknown): string {
+  const code = chatErrorCode(err)
+  if (code === 'RATE_LIMITED' && err instanceof FronteraError) return err.message
+  if (code === 'UNAUTHORIZED') return 'This chat stopped working. Reload the page to start again.'
+  if (code === 'FORBIDDEN') return 'This chat isn’t available on this page.'
+  if (code === 'QUOTA_EXCEEDED' || code === 'SERVICE_UNAVAILABLE') return 'The assistant is unavailable right now. Please try again later.'
+  return 'The message couldn’t be sent. Please try again.'
+}

package/src/element.ts

@@ -0,0 +1,201 @@
+import { visitorErrorWords } from './chat-errors'
+import { PublicChat } from './public-chat'
+import { replyParagraphs } from './reply-text'
+
+/**
+ * `<frontera-chat>`: an Agent on any web page, with no framework (Forge
+ * improvement plan L4). It runs in its own shadow DOM, so the page's styles
+ * and its own never meet, fetches nothing but the chat, and shows the Agent's
+ * replies as plain text, bold and links: no work steps, no artifact viewers,
+ * and no citation links unless `show-sources` is set.
+ *
+ *   <script src="…/frontera-chat.iife.js"></script>
+ *   <frontera-chat api-base-url="https://api.acme.example" publishable-key="fpk_…"></frontera-chat>
+ *
+ * Attributes: `api-base-url` and `publishable-key` (required), `chat-title`,
+ * `placeholder`, `show-sources`. Style it with the custom properties in
+ * `STYLE` (`--frontera-chat-accent` and the rest). It dispatches
+ * `frontera-chat-error` with `{ code, message }` when a send fails.
+ */
+
+const STYLE = `
+:host { display: block; height: 100%; font: 14px/1.45 var(--frontera-chat-font, system-ui, sans-serif); color: var(--frontera-chat-text, #1b1b1f); }
+.frame { display: flex; flex-direction: column; height: 100%; min-height: 320px; background: var(--frontera-chat-surface, #fff); border: 1px solid var(--frontera-chat-border, #e3e3e8); border-radius: var(--frontera-chat-radius, 12px); overflow: hidden; }
+header { padding: 12px 16px; font-weight: 600; border-bottom: 1px solid var(--frontera-chat-border, #e3e3e8); }
+.log { flex: 1; overflow-y: auto; padding: 16px; display: flex; flex-direction: column; gap: 10px; }
+.msg { max-width: 85%; padding: 8px 12px; border-radius: 12px; white-space: normal; overflow-wrap: anywhere; }
+.msg p { margin: 0 0 8px; } .msg p:last-child { margin: 0; }
+.agent { align-self: flex-start; background: var(--frontera-chat-agent-bubble, #f1f1f4); }
+.visitor { align-self: flex-end; background: var(--frontera-chat-accent, #2f5bea); color: var(--frontera-chat-accent-text, #fff); }
+.note { align-self: center; font-size: 12px; color: var(--frontera-chat-muted, #6b6b76); }
+.typing { align-self: flex-start; color: var(--frontera-chat-muted, #6b6b76); font-size: 12px; }
+a { color: inherit; }
+form { display: flex; gap: 8px; padding: 12px; border-top: 1px solid var(--frontera-chat-border, #e3e3e8); }
+textarea { flex: 1; resize: none; font: inherit; padding: 8px 10px; border: 1px solid var(--frontera-chat-border, #e3e3e8); border-radius: 8px; min-height: 20px; max-height: 120px; }
+button { font: inherit; padding: 0 14px; border: 0; border-radius: 8px; background: var(--frontera-chat-accent, #2f5bea); color: var(--frontera-chat-accent-text, #fff); cursor: pointer; }
+button:disabled { opacity: .5; cursor: default; }
+`
+
+// Safe to import where there is no DOM (server rendering): the class is only defined in a browser.
+const Base = (typeof HTMLElement === 'undefined' ? class {} : HTMLElement) as typeof HTMLElement
+
+export class FronteraChatElement extends Base {
+  static observedAttributes = ['chat-title', 'placeholder']
+
+  private chat: PublicChat | null = null
+  private log!: HTMLElement
+  private input!: HTMLTextAreaElement
+  private sendButton!: HTMLButtonElement
+  private header!: HTMLElement
+  private busy = false
+
+  connectedCallback(): void {
+    if (this.chat) return
+    const root = this.shadowRoot ?? this.attachShadow({ mode: 'open' })
+    const doc = this.ownerDocument
+    const style = doc.createElement('style')
+    style.textContent = STYLE
+    const frame = doc.createElement('div')
+    frame.className = 'frame'
+    this.header = doc.createElement('header')
+    this.log = doc.createElement('div')
+    this.log.className = 'log'
+    this.log.setAttribute('role', 'log')
+    this.log.setAttribute('aria-live', 'polite')
+    const form = doc.createElement('form')
+    this.input = doc.createElement('textarea')
+    this.input.rows = 1
+    this.input.setAttribute('aria-label', 'Message')
+    this.sendButton = doc.createElement('button')
+    this.sendButton.type = 'submit'
+    this.sendButton.textContent = 'Send'
+    form.append(this.input, this.sendButton)
+    frame.append(this.header, this.log, form)
+    root.replaceChildren(style, frame)
+    this.applyAttributes()
+
+    form.addEventListener('submit', (e) => {
+      e.preventDefault()
+      void this.submit()
+    })
+    this.input.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault()
+        void this.submit()
+      }
+    })
+
+    const apiBaseUrl = this.getAttribute('api-base-url')?.replace(/\/+$/, '')
+    const publishableKey = this.getAttribute('publishable-key')
+    if (!apiBaseUrl || !publishableKey) {
+      this.note('This chat is missing its api-base-url or publishable-key.')
+      this.setBusy(true)
+      return
+    }
+    this.chat = new PublicChat({ apiBaseUrl, publishableKey })
+    this.chat
+      .open()
+      .then(({ openingMessage }) => {
+        if (openingMessage) this.agentBubble().replaceChildren(...this.render(openingMessage))
+      })
+      // The first send mints again and says what failed.
+      .catch(() => {})
+  }
+
+  attributeChangedCallback(): void {
+    if (this.header) this.applyAttributes()
+  }
+
+  private applyAttributes(): void {
+    const title = this.getAttribute('chat-title')
+    this.header.textContent = title ?? ''
+    this.header.hidden = !title
+    this.input.placeholder = this.getAttribute('placeholder') ?? 'Type a message'
+  }
+
+  private setBusy(busy: boolean): void {
+    this.busy = busy
+    this.sendButton.disabled = busy
+  }
+
+  private note(text: string): void {
+    const el = this.ownerDocument.createElement('div')
+    el.className = 'note'
+    el.textContent = text
+    this.log.append(el)
+  }
+
+  private agentBubble(): HTMLElement {
+    const el = this.ownerDocument.createElement('div')
+    el.className = 'msg agent'
+    this.log.append(el)
+    return el
+  }
+
+  /** The reply as paragraphs of text, bold and links, built as nodes: nothing from the reply becomes HTML. */
+  private render(text: string): HTMLElement[] {
+    const doc = this.ownerDocument
+    return replyParagraphs(text, { showSources: this.hasAttribute('show-sources') }).map((lines) => {
+      const p = doc.createElement('p')
+      lines.forEach((pieces, i) => {
+        if (i > 0) p.append(doc.createElement('br'))
+        for (const piece of pieces) {
+          if (piece.kind === 'text') p.append(doc.createTextNode(piece.text))
+          else if (piece.kind === 'bold') {
+            const b = doc.createElement('strong')
+            b.textContent = piece.text
+            p.append(b)
+          } else {
+            const a = doc.createElement('a')
+            a.href = piece.href
+            a.textContent = piece.text
+            a.target = '_blank'
+            a.rel = 'noopener noreferrer'
+            p.append(a)
+          }
+        }
+      })
+      return p
+    })
+  }
+
+  private async submit(): Promise<void> {
+    const text = this.input.value.trim()
+    if (!text || this.busy || !this.chat) return
+    this.input.value = ''
+    const mine = this.ownerDocument.createElement('div')
+    mine.className = 'msg visitor'
+    mine.textContent = text
+    this.log.append(mine)
+    this.setBusy(true)
+    const typing = this.ownerDocument.createElement('div')
+    typing.className = 'typing'
+    typing.textContent = 'Typing…'
+    let bubble: HTMLElement | null = null
+    try {
+      for await (const event of this.chat.send(text)) {
+        if (event.type === 'waiting') this.log.append(typing)
+        else if (event.type === 'text') {
+          typing.remove()
+          bubble ??= this.agentBubble()
+          bubble.replaceChildren(...this.render(event.text))
+        } else if (event.type === 'error') {
+          typing.remove()
+          this.note(visitorErrorWords(event.error))
+          this.dispatchEvent(new CustomEvent('frontera-chat-error', { detail: { code: event.error.code, message: event.error.message } }))
+        }
+        this.log.scrollTop = this.log.scrollHeight
+      }
+    } finally {
+      typing.remove()
+      this.setBusy(false)
+      this.input.focus()
+    }
+  }
+}
+
+/** Register the element under `tag` (once); the script-tag build calls it for you. */
+export function defineFronteraChat(tag = 'frontera-chat'): void {
+  if (typeof customElements === 'undefined' || customElements.get(tag)) return
+  customElements.define(tag, class extends FronteraChatElement {})
+}

package/src/frontera-chat.global.ts

@@ -0,0 +1,13 @@
+/**
+ * The script-tag build (`dist/frontera-chat.iife.js`): loading it registers
+ * `<frontera-chat>` and exposes `window.FronteraChat` for a chat of your own
+ * design. It carries everything it needs; there is nothing else to install.
+ */
+import { CHAT_ERROR_CODES, chatErrorCode, visitorErrorWords } from './chat-errors'
+import { defineFronteraChat, FronteraChatElement } from './element'
+import { PublicChat } from './public-chat'
+import { mintPublicChatToken } from './public-token'
+
+defineFronteraChat()
+
+export { CHAT_ERROR_CODES, chatErrorCode, defineFronteraChat, FronteraChatElement, mintPublicChatToken, PublicChat, visitorErrorWords }

package/src/public-chat.ts

@@ -0,0 +1,154 @@
+import { FronteraClient } from '@frontera-sdk/core/client'
+import { FronteraError } from '@frontera-sdk/core/errors'
+
+import { chatErrorCode } from './chat-errors'
+import { mintPublicChatToken, type PublicChatTokenOptions } from './public-token'
+import { startChat } from './stream'
+import type { ChatInputMessage } from './types'
+
+/**
+ * A website visitor's conversation without React or the AI SDK (Forge
+ * improvement plan L4): mint the visitor's token, send a message, read the
+ * reply as it arrives. `<frontera-chat>` is built on it; use it directly for a
+ * chat of your own design.
+ *
+ * Under the Agent's reply checks the platform holds a reply until it is
+ * checked, so it can arrive in one piece after a pause: `waiting` says the
+ * Agent is working, and the text follows once it may be shown.
+ */
+
+export type PublicChatEvent =
+  | { type: 'waiting' }
+  | { type: 'text'; text: string }
+  | { type: 'done' }
+  | { type: 'error'; error: FronteraError }
+
+export interface PublicChatOptions extends Omit<PublicChatTokenOptions, 'fetchImpl'> {
+  /** Test seam. Defaults to the global. */
+  fetchImpl?: typeof fetch
+}
+
+function newId(): string {
+  return typeof crypto !== 'undefined' && 'randomUUID' in crypto ? crypto.randomUUID() : `m-${Date.now()}-${Math.random().toString(36).slice(2)}`
+}
+
+/** The JSON events of a chat's server-sent event stream, the keepalive comments and the terminator left out. */
+export async function* chatEvents(response: Response): AsyncGenerator<Record<string, unknown>> {
+  if (!response.body) return
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  const parse = (block: string): Record<string, unknown> | null => {
+    const data = block
+      .split('\n')
+      .filter((line) => line.startsWith('data:'))
+      .map((line) => line.slice(5).trimStart())
+      .join('\n')
+    if (!data || data === '[DONE]') return null
+    try {
+      const value = JSON.parse(data) as unknown
+      return value && typeof value === 'object' ? (value as Record<string, unknown>) : null
+    } catch {
+      return null
+    }
+  }
+  for (;;) {
+    const { done, value } = await reader.read()
+    if (value) buffer += decoder.decode(value, { stream: true })
+    let end = buffer.indexOf('\n\n')
+    while (end !== -1) {
+      const event = parse(buffer.slice(0, end))
+      buffer = buffer.slice(end + 2)
+      if (event) yield event
+      end = buffer.indexOf('\n\n')
+    }
+    if (done) break
+  }
+  const last = parse(buffer)
+  if (last) yield last
+}
+
+export class PublicChat {
+  private token: string | null = null
+  private conversationId: string | null = null
+  /** Shown before the first message; sent back with it, so the conversation keeps it. */
+  openingMessage: string | null = null
+  private opened = false
+
+  constructor(private readonly options: PublicChatOptions) {}
+
+  /** Mint the visitor's token, and learn the Agent's opening message. Called by `send` when needed. */
+  async open(): Promise<{ openingMessage: string | null }> {
+    const minted = await mintPublicChatToken({ ...this.options, ...(this.options.fetchImpl ? { fetchImpl: this.options.fetchImpl } : {}) })
+    this.token = minted.token
+    if (!this.opened) this.openingMessage = minted.openingMessage ?? null
+    this.opened = true
+    return { openingMessage: this.openingMessage }
+  }
+
+  private client(): FronteraClient {
+    return new FronteraClient(
+      { apiBaseUrl: this.options.apiBaseUrl, credential: { kind: 'token', token: this.token! } },
+      this.options.fetchImpl ?? fetch,
+    )
+  }
+
+  private messagesFor(text: string): ChatInputMessage[] {
+    const user = { id: newId(), role: 'user' as const, parts: [{ type: 'text' as const, text }] }
+    // The first turn carries the opening message the visitor saw, unchanged.
+    if (this.conversationId || !this.openingMessage) return [user]
+    return [{ id: newId(), role: 'assistant', parts: [{ type: 'text', text: this.openingMessage }] }, user]
+  }
+
+  /** Send one message and read the reply: `waiting`, then the reply's text as it grows, then `done` (or `error`). */
+  async *send(text: string, signal?: AbortSignal): AsyncGenerator<PublicChatEvent> {
+    yield { type: 'waiting' }
+    let response: Response
+    try {
+      if (!this.token) await this.open()
+      const start = () =>
+        startChat(this.client(), { messages: this.messagesFor(text), ...(this.conversationId ? { conversationId: this.conversationId } : {}) }, { signal })
+      let run
+      try {
+        run = await start()
+      } catch (err) {
+        // A lapsed token: mint again (the visitor pass keeps the same visitor) and send once more.
+        if (chatErrorCode(err) !== 'UNAUTHORIZED') throw err
+        await this.open()
+        run = await start()
+      }
+      this.conversationId = run.conversationId
+      response = run.response
+    } catch (err) {
+      yield { type: 'error', error: asFronteraError(err) }
+      return
+    }
+
+    const parts = new Map<string, string>()
+    const order: string[] = []
+    const whole = () => order.map((id) => parts.get(id) ?? '').filter(Boolean).join('\n\n')
+    try {
+      for await (const event of chatEvents(response)) {
+        if (event.type === 'text-delta' && typeof event.delta === 'string') {
+          const id = typeof event.id === 'string' ? event.id : 'text'
+          if (!parts.has(id)) order.push(id)
+          parts.set(id, (parts.get(id) ?? '') + event.delta)
+          yield { type: 'text', text: whole() }
+        } else if (event.type === 'error') {
+          const message = typeof event.errorText === 'string' ? event.errorText : 'The reply failed.'
+          yield { type: 'error', error: new FronteraError(message, { code: 'INTERNAL_ERROR' }) }
+          return
+        }
+      }
+    } catch (err) {
+      yield { type: 'error', error: asFronteraError(err) }
+      return
+    }
+    yield { type: 'done' }
+  }
+}
+
+function asFronteraError(err: unknown): FronteraError {
+  if (err instanceof FronteraError) return err
+  return new FronteraError(err instanceof Error ? err.message : String(err), { code: 'INTERNAL_ERROR' })
+}

package/src/public-token.ts

@@ -26,6 +26,29 @@ export interface PublicChatTokenOptions {
   fetchImpl?: typeof fetch
   /** Test seam. Defaults to `localStorage`, when there is one. */
   storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | null
+  /**
+   * The visitor's language (`en-GB`, `id`), for the Agent's opening message.
+   * Defaults to the browser's (`navigator.language`).
+   */
+  language?: string
+}
+
+/** A visitor's token, with what the Agent says first when it has an opening message. */
+export interface PublicChatToken extends ChatToken {
+  /**
+   * The Agent's opening message in the visitor's language, to show before they
+   * type. Send it back unchanged as an `assistant` message before the
+   * visitor's first message, and the conversation keeps it as the Agent's.
+   */
+  openingMessage?: string
+}
+
+function browserLanguage(): string | undefined {
+  try {
+    return typeof navigator === 'undefined' ? undefined : navigator.language || undefined
+  } catch {
+    return undefined
+  }
 }
 
 /** One pass per key, so two Agents on one site never share a visitor. */
@@ -57,23 +80,32 @@ function write(storage: PublicChatTokenOptions['storage'], key: string, value: s
   }
 }
 
-export async function mintPublicChatToken(options: PublicChatTokenOptions): Promise<ChatToken> {
+export async function mintPublicChatToken(options: PublicChatTokenOptions): Promise<PublicChatToken> {
   const storage = options.storage === undefined ? defaultStorage() : options.storage
   const passKey = visitorPassStorageKey(options.publishableKey)
   const visitorPass = read(storage, passKey)
+  const language = options.language ?? browserLanguage()
 
   const response = await (options.fetchImpl ?? fetch)(`${options.apiBaseUrl}/v1/chat-tokens/public`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
     // Never `include`: this call carries the key, not anyone's cookies.
     credentials: 'omit',
-    body: JSON.stringify({ publishableKey: options.publishableKey, ...(visitorPass ? { visitorPass } : {}) }),
+    body: JSON.stringify({
+      publishableKey: options.publishableKey,
+      ...(visitorPass ? { visitorPass } : {}),
+      ...(language ? { language } : {}),
+    }),
   })
   const body = (await response.json().catch(() => null)) as
-    | { data?: { token: string; expiresAt: string; visitorPass?: string } }
+    | { data?: { token: string; expiresAt: string; visitorPass?: string; openingMessage?: string } }
     | null
   if (!response.ok || !body?.data) throw errorFromResponse(response.status, body)
 
   if (body.data.visitorPass) write(storage, passKey, body.data.visitorPass)
-  return { token: body.data.token, expiresAt: body.data.expiresAt }
+  return {
+    token: body.data.token,
+    expiresAt: body.data.expiresAt,
+    ...(body.data.openingMessage ? { openingMessage: body.data.openingMessage } : {}),
+  }
 }

package/src/reply-text.ts

@@ -0,0 +1,49 @@
+/**
+ * An Agent's reply as a page without a Markdown renderer shows it (Forge
+ * improvement plan L4): citation links out unless the page shows sources,
+ * then paragraphs of plain text, bold and links. No HTML is ever produced
+ * from the reply; the element builds DOM nodes from these pieces.
+ */
+
+/** `[1](/cite/knowledge/…)`, a citation the platform links to its own source viewer. */
+const CITATION = /\s?\[([^\]]*)\]\(\/cite\/[^)\s]*\)/g
+
+/** The reply without its citations: a numbered one goes, a named one keeps its name. */
+export function withoutCitations(text: string): string {
+  return text.replace(CITATION, (match, label: string) => (/^\s*\d+\s*$/.test(label) ? '' : match.startsWith(' ') ? ` ${label}` : label))
+}
+
+export type ReplyPiece = { kind: 'text'; text: string } | { kind: 'bold'; text: string } | { kind: 'link'; text: string; href: string }
+
+/** Only web and mail links become links; anything else stays text. */
+function safeHref(href: string): string | null {
+  return /^(https?:\/\/|mailto:)/i.test(href.trim()) ? href.trim() : null
+}
+
+const INLINE = /\*\*([^*]+)\*\*|\[([^\]]+)\]\(([^)\s]+)\)/g
+
+function pieces(line: string): ReplyPiece[] {
+  const out: ReplyPiece[] = []
+  let at = 0
+  for (const m of line.matchAll(INLINE)) {
+    if (m.index! > at) out.push({ kind: 'text', text: line.slice(at, m.index) })
+    if (m[1] !== undefined) out.push({ kind: 'bold', text: m[1] })
+    else {
+      const href = safeHref(m[3]!)
+      out.push(href ? { kind: 'link', text: m[2]!, href } : { kind: 'text', text: m[2]! })
+    }
+    at = m.index! + m[0].length
+  }
+  if (at < line.length) out.push({ kind: 'text', text: line.slice(at) })
+  return out
+}
+
+/** Paragraphs (split on blank lines), each a list of lines, each line its pieces. */
+export function replyParagraphs(text: string, options: { showSources?: boolean } = {}): ReplyPiece[][][] {
+  const shown = options.showSources ? text : withoutCitations(text)
+  return shown
+    .split(/\n\s*\n/)
+    .map((p) => p.trim())
+    .filter(Boolean)
+    .map((p) => p.split('\n').map((line) => pieces(line.replace(/^\s*[-*]\s+/, '• '))))
+}

package/src/transport.ts

@@ -6,6 +6,9 @@ import { chatDoctor } from './doctor'
 
 import type { StartChatRequest } from './types'
 
+/** The id of the Agent's opening message a chat shows before the person's first message (L4). */
+export const OPENING_MESSAGE_ID = 'frontera-opening'
+
 export interface ChatTransportOptions {
   /** Continue an existing conversation. Omit to let the server create one. */
   conversationId?: string
@@ -176,11 +179,14 @@ export function createChatTransport(
     */
     prepareSendMessagesRequest: ({ messages, body }) => {
       const lastUserMessage = [...messages].reverse().find((m) => m.role === 'user')
+      // A new conversation's first turn carries the opening message the person saw, unchanged, so it is kept as the Agent's first message.
+      const before = lastUserMessage ? messages[messages.indexOf(lastUserMessage) - 1] : undefined
+      const opening = !conversationId && before?.role === 'assistant' && before.id === OPENING_MESSAGE_ID ? [before] : []
       const trimmed =
         options.lastMessageOnly === false
           ? messages
           : lastUserMessage
-            ? [lastUserMessage]
+            ? [...opening, lastUserMessage]
             : messages.slice(-1)
       return {
         api: `${current().config.apiBaseUrl}/v1/chat`,