dsh-bailinghub 0.3.0 → 0.5.0

package/lib/conversation-archive-store.js

@@ -0,0 +1,265 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { constants } from 'node:fs'
+import { lstat, mkdir, open, rename, unlink } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
+
+const SCHEMAS = new Set(['bailing.agent-conversation-outbox.v1', 'bailing.agent-conversation-outbox.v2'])
+const MAX_BYTES = 32 * 1024 * 1024
+const LOCK_TIMEOUT_MS = 1_000
+const SECRET_KEYS = new Set(['token', 'accesstoken', 'refreshtoken', 'password', 'clientsecret', 'authorization', 'credential', 'credentials'])
+
+function storeError(code = 'ARCHIVE_STORE_UNAVAILABLE') {
+  const error = new Error(code === 'ARCHIVE_STORE_CONFLICT'
+    ? 'The conversation archive changed or is being saved. Read it again before retrying.'
+    : 'The conversation archive store is unavailable. The archive was not safely saved.')
+  error.code = code
+  return error
+}
+
+function safeError(error) {
+  return ['ARCHIVE_STORE_CONFLICT', 'ARCHIVE_STORE_UNAVAILABLE'].includes(error?.code)
+    ? error : storeError()
+}
+
+function sessionKey(sessionId) {
+  if (typeof sessionId !== 'string' || !sessionId.length || sessionId.length > 4_096) throw storeError()
+  return createHash('sha256').update(sessionId).digest('hex')
+}
+
+// The archive coordinator owns the event schema. This boundary additionally refuses
+// non-JSON values and credential fields so stores cannot become credential caches.
+function snapshotJson(value, seen = new Set()) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value
+  if (typeof value === 'number' && Number.isFinite(value) && !Object.is(value, -0)) return value
+  if (!value || typeof value !== 'object' || seen.has(value)) throw storeError()
+  const array = Array.isArray(value)
+  if (!array && ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw storeError()
+  seen.add(value)
+  try {
+    const entries = Reflect.ownKeys(value).filter((key) => !array || key !== 'length')
+    if (array && (entries.length !== value.length || entries.some((key, index) => key !== String(index)))) throw storeError()
+    const copy = array ? [] : {}
+    for (const key of entries) {
+      const property = Object.getOwnPropertyDescriptor(value, key)
+      if (typeof key !== 'string' || !property.enumerable || !Object.hasOwn(property, 'value') ||
+        SECRET_KEYS.has(key.replace(/[_-]/gu, '').toLowerCase()) || ['__proto__', 'constructor', 'prototype'].includes(key)) throw storeError()
+      copy[key] = snapshotJson(property.value, seen)
+    }
+    return copy
+  } finally {
+    seen.delete(value)
+  }
+}
+
+function snapshotRecord(sessionId, record) {
+  const copy = snapshotJson(record)
+  if (!copy || Array.isArray(copy) || !SCHEMAS.has(copy.schema) || copy.sessionId !== sessionId ||
+    !Number.isSafeInteger(copy.revision) || copy.revision < 1) throw storeError()
+  if (Buffer.byteLength(JSON.stringify(copy)) > MAX_BYTES) throw storeError()
+  return copy
+}
+
+function nextRecord(sessionId, record, expectedRevision) {
+  sessionKey(sessionId)
+  if (expectedRevision !== null && (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1)) throw storeError()
+  const copy = snapshotRecord(sessionId, record)
+  if (copy.revision !== (expectedRevision ?? 0) + 1) throw storeError()
+  return copy
+}
+
+function assertRevision(current, expectedRevision) {
+  if ((current?.revision ?? null) !== expectedRevision) throw storeError('ARCHIVE_STORE_CONFLICT')
+}
+
+function assertOwned(stat, kind) {
+  if (!(kind === 'directory' ? stat.isDirectory() : stat.isFile()) ||
+    (kind === 'file' && stat.nlink !== 1) ||
+    (typeof process.getuid === 'function' && stat.uid !== process.getuid()) ||
+    (process.platform !== 'win32' && (stat.mode & 0o777) !== (kind === 'directory' ? 0o700 : 0o600))) throw storeError()
+}
+
+function sameFile(a, b) {
+  return a.dev === b.dev && a.ino === b.ino
+}
+
+function defaultDirectory() {
+  const configured = process.env.DSH_HOME
+  const base = typeof configured === 'string' && configured.trim() ? configured : join(homedir(), '.dsh')
+  const expanded = base === '~' ? homedir() : /^~[/\\]/u.test(base) ? join(homedir(), base.slice(2)) : base
+  return join(resolve(expanded), 'plugins', 'dsh-bailinghub', 'conversation-outbox')
+}
+
+async function ensureDirectory(directory, create) {
+  if (create) await mkdir(directory, { recursive: true, mode: 0o700 })
+  let stat
+  try {
+    stat = await lstat(directory)
+  } catch (error) {
+    if (!create && error.code === 'ENOENT') return false
+    throw error
+  }
+  assertOwned(stat, 'directory')
+  return true
+}
+
+async function readRecord(path, sessionId) {
+  let before
+  try {
+    before = await lstat(path)
+  } catch (error) {
+    if (error.code === 'ENOENT') return null
+    throw error
+  }
+  assertOwned(before, 'file')
+  if (before.size > MAX_BYTES) throw storeError()
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
+  try {
+    const opened = await file.stat()
+    assertOwned(opened, 'file')
+    if (!sameFile(before, opened) || opened.size > MAX_BYTES) throw storeError()
+    // Bound the read even if an abnormal writer grows the file after fstat.
+    const bytes = Buffer.alloc(MAX_BYTES + 1)
+    let length = 0
+    while (length < bytes.length) {
+      const result = await file.read(bytes, length, bytes.length - length, length)
+      if (!result.bytesRead) break
+      length += result.bytesRead
+    }
+    if (length > MAX_BYTES) throw storeError()
+    return snapshotRecord(sessionId, JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, length))))
+  } finally {
+    await file.close()
+  }
+}
+
+async function acquireLock(path) {
+  const deadline = performance.now() + LOCK_TIMEOUT_MS
+  while (true) {
+    let file
+    let stat
+    try {
+      file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600)
+      stat = await file.stat()
+      await file.chmod(0o600)
+      assertOwned(await file.stat(), 'file')
+      return { file, stat }
+    } catch (error) {
+      if (file) {
+        if (stat) await releaseLock(path, { file, stat })
+        else await file.close().catch(() => {})
+      }
+      if (error.code !== 'EEXIST') throw error
+      try {
+        assertOwned(await lstat(path), 'file')
+      } catch (inspectionError) {
+        if (inspectionError.code === 'ENOENT') continue
+        throw inspectionError
+      }
+      if (performance.now() >= deadline) throw storeError('ARCHIVE_STORE_CONFLICT')
+      // Never infer staleness or remove another process's lock.
+      await delay(20)
+    }
+  }
+}
+
+async function releaseLock(path, lock) {
+  try {
+    const current = await lstat(path)
+    if (!sameFile(current, lock.stat) || !current.isFile()) throw storeError()
+    await unlink(path)
+  } finally {
+    await lock.file.close()
+  }
+}
+
+async function syncDirectory(directory) {
+  // Windows does not expose fsync on directory handles through Node.
+  if (process.platform === 'win32') return
+  const handle = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW)
+  try {
+    assertOwned(await handle.stat(), 'directory')
+    await handle.sync()
+  } finally {
+    await handle.close()
+  }
+}
+
+/** Private transcript outboxes. No user directory is touched until load/save. */
+export function createFileConversationArchiveStore({ directory } = {}) {
+  if (directory !== undefined && (typeof directory !== 'string' || !directory.trim())) throw storeError()
+  const root = directory === undefined ? defaultDirectory() : resolve(directory)
+  return {
+    async load(sessionId) {
+      try {
+        const key = sessionKey(sessionId)
+        if (!await ensureDirectory(root, false)) return null
+        return await readRecord(join(root, `${key}.json`), sessionId)
+      } catch (error) {
+        throw safeError(error)
+      }
+    },
+    async save(sessionId, record, expectedRevision) {
+      let lock
+      let temporaryPath
+      const key = sessionKey(sessionId)
+      const path = join(root, `${key}.json`)
+      const lockPath = join(root, `${key}.lock`)
+      try {
+        const copy = nextRecord(sessionId, record, expectedRevision)
+        await ensureDirectory(root, true)
+        lock = await acquireLock(lockPath)
+        assertRevision(await readRecord(path, sessionId), expectedRevision)
+        temporaryPath = join(root, `.${key}.${randomUUID()}.tmp`)
+        const temporary = await open(temporaryPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600)
+        try {
+          await temporary.chmod(0o600)
+          assertOwned(await temporary.stat(), 'file')
+          await temporary.writeFile(JSON.stringify(copy), 'utf8')
+          await temporary.sync()
+        } finally {
+          await temporary.close()
+        }
+        await rename(temporaryPath, path)
+        temporaryPath = undefined
+        await syncDirectory(root)
+        return snapshotRecord(sessionId, copy)
+      } catch (error) {
+        throw safeError(error)
+      } finally {
+        try {
+          if (temporaryPath) await unlink(temporaryPath).catch((error) => {
+            if (error.code !== 'ENOENT') throw storeError()
+          })
+        } finally {
+          if (lock) {
+            try {
+              await releaseLock(lockPath, lock)
+            } catch {
+              throw storeError()
+            }
+          }
+        }
+      }
+    },
+  }
+}
+
+/** Explicit in-memory adapter: CAS-compatible, but never survives process restart. */
+export function createMemoryConversationArchiveStore() {
+  const records = new Map()
+  return {
+    async load(sessionId) {
+      sessionKey(sessionId)
+      const record = records.get(sessionId)
+      return record ? snapshotRecord(sessionId, record) : null
+    },
+    async save(sessionId, record, expectedRevision) {
+      const copy = nextRecord(sessionId, record, expectedRevision)
+      assertRevision(records.get(sessionId), expectedRevision)
+      records.set(sessionId, copy)
+      return snapshotRecord(sessionId, copy)
+    },
+  }
+}

package/lib/conversation-outbox.js

@@ -0,0 +1,236 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { createFileConversationArchiveStore } from './conversation-archive-store.js'
+
+const SCHEMA = 'bailing.agent-conversation-outbox.v1'
+const TARGET_SCHEMA = 'bailing.agent-conversation-outbox.v2'
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+const KEY = /^conn_[0-9a-f]{32}$/
+const KINDS = new Set(['turn_start', 'user_message', 'assistant_message', 'run_link', 'turn_end'])
+const digest = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex')
+const fail = (code = 'ARCHIVE_INVALID') => Object.assign(new Error(`Conversation archive unavailable (${code})`), { code })
+
+function eventPayload(value) {
+  const copy = structuredClone(value)
+  if (!copy || !KINDS.has(copy.kind) || typeof copy.client_turn_id !== 'string' || !copy.client_turn_id || copy.client_turn_id.length > 256 ||
+    Object.keys(copy).some((key) => !['kind', 'client_turn_id', 'content', 'run_id', 'member_session_id', 'status'].includes(key))) throw fail()
+  const message = ['user_message', 'assistant_message'].includes(copy.kind)
+  // Preserve over-limit visible text locally. The SDK rejects a message above
+  // its remote limit; silently truncating it would fabricate a full transcript.
+  if (message ? typeof copy.content !== 'string' : Object.hasOwn(copy, 'content')) throw fail('ARCHIVE_MESSAGE_INVALID')
+  if (copy.kind === 'run_link' ? !UUID.test(copy.run_id ?? '') || !UUID.test(copy.member_session_id ?? '')
+    : Object.hasOwn(copy, 'run_id') || Object.hasOwn(copy, 'member_session_id')) throw fail()
+  if (copy.kind === 'turn_end' ? !['completed', 'failed', 'cancelled'].includes(copy.status) : Object.hasOwn(copy, 'status')) throw fail()
+  return copy
+}
+
+function contextSnapshot(value) {
+  const copy = structuredClone(value)
+  const crossSystem = copy?.binding && !Object.hasOwn(copy.binding, 'clientAppId')
+  if (typeof copy?.clientConversationId !== 'string' || !copy.clientConversationId || copy.clientConversationId.length > 256 ||
+    !copy.binding || typeof copy.binding.hubUrl !== 'string' ||
+    (!crossSystem && (typeof copy.binding.clientAppId !== 'string' || typeof copy.binding.workspace !== 'string')) ||
+    !Array.isArray(copy.members) || !copy.members.length || copy.members.length > 64 ||
+    Object.keys(copy).some((key) => !['clientConversationId', 'binding', 'members'].includes(key)) ||
+    Object.keys(copy.binding).some((key) => !(crossSystem ? ['hubUrl'] : ['hubUrl', 'clientAppId', 'workspace']).includes(key))) throw fail('ARCHIVE_MEMBERS_INVALID')
+  const keys = new Set()
+  const identities = new Set()
+  for (const member of copy.members) {
+    if (!KEY.test(member?.connectionKey ?? '') || keys.has(member.connectionKey) || !UUID.test(member.expectedSessionId ?? '') ||
+      identities.has(member.expectedSessionId.toLowerCase()) ||
+      (crossSystem ? member.hubUrl !== copy.binding.hubUrl || !/^[a-z0-9][a-z0-9_-]{1,63}$/.test(member.clientAppId ?? '') || !/^[a-z0-9][a-z0-9_-]{1,63}$/.test(member.workspace ?? '')
+        : member.workspace !== copy.binding.workspace) || typeof member.label !== 'string' || member.label.length > 128 ||
+      Object.keys(member).some((key) => !['connectionKey', 'workspace', 'expectedSessionId', 'label', ...(crossSystem ? ['hubUrl', 'clientAppId'] : [])].includes(key))) throw fail('ARCHIVE_MEMBERS_INVALID')
+    keys.add(member.connectionKey)
+    identities.add(member.expectedSessionId.toLowerCase())
+  }
+  return copy
+}
+
+function validateRecord(record, sessionId, context) {
+  if (!record || record.schema !== (Object.hasOwn(context.binding, 'clientAppId') ? SCHEMA : TARGET_SCHEMA) || record.sessionId !== sessionId || !Number.isSafeInteger(record.revision) || record.revision < 1 ||
+    !UUID.test(record.clientArchiveId ?? '') || digest(contextSnapshot(record.context)) !== digest(context) ||
+    !Number.isSafeInteger(record.acknowledged) || record.acknowledged < 0 || !Array.isArray(record.events) || record.acknowledged > record.events.length ||
+    record.conversationId !== null && !UUID.test(record.conversationId ?? '') ||
+    Object.keys(record).some((key) => !['schema', 'sessionId', 'revision', 'clientArchiveId', 'context', 'acknowledged', 'conversationId', 'events', 'syncState'].includes(key)) ||
+    !['pending', 'synced', 'unsupported'].includes(record.syncState)) throw fail('ARCHIVE_BINDING_CHANGED')
+  const sources = new Set()
+  const ids = new Set()
+  const turns = new Map()
+  for (const [index, item] of record.events.entries()) {
+    const { event_id: id, sequence, ...payload } = item?.event ?? {}
+    const checked = eventPayload(payload)
+    if (Object.keys(item).some((key) => !['source', 'hash', 'event'].includes(key)) || !/^[a-f0-9]{64}$/.test(item.source ?? '') || sources.has(item.source) ||
+      !UUID.test(id ?? '') || ids.has(id) || sequence !== index + 1 || item.hash !== digest(checked)) throw fail('ARCHIVE_INVALID')
+    if (checked.kind === 'run_link' && !context.members.some((member) => member.expectedSessionId === checked.member_session_id)) throw fail('ARCHIVE_MEMBERS_INVALID')
+    const phase = turns.get(checked.client_turn_id)
+    if (checked.kind === 'turn_start' ? phase !== undefined
+      : checked.kind === 'run_link' ? !['started', 'ended'].includes(phase) : phase !== 'started') throw fail('ARCHIVE_EVENT_ORDER')
+    if (checked.kind === 'turn_start') turns.set(checked.client_turn_id, 'started')
+    if (checked.kind === 'turn_end') turns.set(checked.client_turn_id, 'ended')
+    sources.add(item.source)
+    ids.add(id)
+  }
+  return structuredClone(record)
+}
+
+/** One durable visible transcript, independent from per-authorization business runs. */
+export class ConversationOutbox {
+  constructor({ store = createFileConversationArchiveStore() } = {}) {
+    if (typeof store?.load !== 'function' || typeof store?.save !== 'function') throw fail('ARCHIVE_STORE_INVALID')
+    this.store = store
+    this.entries = new Map()
+  }
+
+  serialize(entry, action) {
+    const promise = (entry.queue ?? Promise.resolve()).then(action)
+    entry.queue = promise.catch(() => {})
+    return promise
+  }
+
+  async load(entry) {
+    if (entry.record) return entry.record
+    const saved = await this.store.load(entry.sessionId)
+    if (saved) entry.record = validateRecord(saved, entry.sessionId, entry.context)
+    else {
+      const record = {
+        schema: Object.hasOwn(entry.context.binding, 'clientAppId') ? SCHEMA : TARGET_SCHEMA,
+        sessionId: entry.sessionId, revision: 1, clientArchiveId: randomUUID(), context: entry.context,
+        acknowledged: 0, conversationId: null, events: [], syncState: 'pending',
+      }
+      await this.store.save(entry.sessionId, record, null)
+      entry.record = structuredClone(record)
+    }
+    return entry.record
+  }
+
+  open(sessionId, value) {
+    const context = contextSnapshot(value)
+    let entry = this.entries.get(sessionId)
+    if (entry && digest(entry.context) !== digest(context)) throw fail('ARCHIVE_BINDING_CHANGED')
+    if (!entry) {
+      entry = { sessionId, context, pending: [], status: 'pending' }
+      this.entries.set(sessionId, entry)
+    }
+    return this.serialize(entry, async () => {
+      try { await this.load(entry); entry.status = entry.pending.length ? 'storage_error' : entry.record.syncState; return this.status(sessionId) }
+      catch (error) { entry.status = 'storage_error'; throw error }
+    })
+  }
+
+  async save(entry, values) {
+    const previous = entry.record
+    const record = validateRecord({ ...previous, ...values, revision: previous.revision + 1 }, entry.sessionId, entry.context)
+    await this.store.save(entry.sessionId, record, previous.revision)
+    entry.record = record
+  }
+
+  append(sessionId, source, payload) {
+    const entry = this.entries.get(sessionId)
+    if (!entry) throw fail('ARCHIVE_NOT_OPEN')
+    // Capture before awaits; never retain mutable host messages or model chunks.
+    const item = { source: digest(String(source)), payload: eventPayload(payload) }
+    entry.pending.push(item)
+    return this.serialize(entry, () => this.persistPending(entry))
+  }
+
+  async persistPending(entry) {
+    try {
+      await this.load(entry)
+      const count = entry.pending.length
+      const events = structuredClone(entry.record.events)
+      for (const pending of entry.pending.slice(0, count)) {
+        const hash = digest(pending.payload)
+        const existing = events.find((event) => event.source === pending.source)
+        if (existing) {
+          if (existing.hash !== hash) throw fail('ARCHIVE_EVENT_CONFLICT')
+          continue
+        }
+        events.push({ source: pending.source, hash, event: { event_id: randomUUID(), sequence: events.length + 1, ...pending.payload } })
+      }
+      if (events.length !== entry.record.events.length) await this.save(entry, { events, syncState: 'pending' })
+      entry.pending.splice(0, count)
+      entry.status = entry.record.syncState
+      return this.status(entry.sessionId)
+    } catch (error) { entry.status = 'storage_error'; throw error }
+  }
+
+  status(sessionId) {
+    const entry = this.entries.get(sessionId)
+    if (!entry) return { state: 'inactive', pendingEvents: 0 }
+    return {
+      state: entry.status, pendingEvents: (entry.record?.events.length ?? 0) - (entry.record?.acknowledged ?? 0),
+      unsavedEvents: entry.pending.length, acknowledgedSequence: entry.record?.acknowledged ?? 0,
+      ...(entry.record?.conversationId ? { conversationId: entry.record.conversationId } : {}),
+    }
+  }
+
+  coverage(sessionId, expected) {
+    const events = this.entries.get(sessionId)?.record?.events ?? []
+    if (!Array.isArray(expected) || expected.length === 0 && events.length > 0) return { coverage: 'unverified' }
+    const available = new Map()
+    const signature = (event) => digest(['user_message', 'assistant_message'].includes(event.kind)
+      ? { kind: event.kind, content: event.content }
+      : { kind: event.kind, client_turn_id: event.client_turn_id, ...(event.status ? { status: event.status } : {}) })
+    for (const { event } of events) {
+      if (event.kind === 'run_link') continue
+      const key = signature(event)
+      available.set(key, (available.get(key) ?? 0) + 1)
+    }
+    let missing = 0
+    for (const event of expected) {
+      const key = signature(event)
+      const count = available.get(key) ?? 0
+      if (count) available.set(key, count - 1)
+      else missing += 1
+    }
+    return missing ? { coverage: 'incomplete', missingVisibleEvents: missing } : { coverage: 'available_host_history_checked' }
+  }
+
+  sync(sessionId, send) {
+    const entry = this.entries.get(sessionId)
+    if (!entry) return Promise.resolve(this.status(sessionId))
+    if (entry.syncing) return entry.syncing
+    entry.syncing = (async () => {
+      while (true) {
+        const snapshot = await this.serialize(entry, async () => {
+          await this.persistPending(entry)
+          return structuredClone(entry.record)
+        })
+        try {
+          const ack = await send({
+            clientArchiveId: snapshot.clientArchiveId, clientConversationId: snapshot.context.clientConversationId,
+            events: snapshot.events.slice(snapshot.acknowledged).map((item) => item.event),
+          }, { members: structuredClone(snapshot.context.members) })
+          if (ack?.schema !== 'bailing.agent-conversation-audit-ack.v1' || !UUID.test(ack.conversation_id ?? '') ||
+            !Number.isSafeInteger(ack.last_sequence) || ack.last_sequence < snapshot.acknowledged || ack.last_sequence > snapshot.events.length ||
+            snapshot.conversationId && ack.conversation_id !== snapshot.conversationId) throw fail('ARCHIVE_ACK_INVALID')
+          await this.serialize(entry, async () => {
+            await this.save(entry, {
+              acknowledged: ack.last_sequence, conversationId: ack.conversation_id,
+              syncState: ack.last_sequence === entry.record.events.length ? 'synced' : 'pending',
+            })
+            entry.status = entry.pending.length ? 'storage_error' : entry.record.syncState
+          })
+          // A final reply may arrive while an earlier batch is in flight. Drain
+          // newly captured events after success, without looping on failures.
+          await this.serialize(entry, () => this.persistPending(entry))
+          if (ack.last_sequence === snapshot.events.length && entry.record.events.length > snapshot.events.length) continue
+        } catch (error) {
+          await this.serialize(entry, async () => {
+            const state = error?.status === 404 || error?.statusCode === 404 || error?.code === 'ARCHIVE_UNSUPPORTED' ? 'unsupported' : 'pending'
+            try { await this.save(entry, { syncState: state }); entry.status = entry.pending.length ? 'storage_error' : state }
+            catch { entry.status = 'storage_error' }
+          })
+        }
+        return this.status(sessionId)
+      }
+    })().catch(() => { entry.status = 'storage_error'; return this.status(sessionId) }).finally(() => { entry.syncing = undefined })
+    return entry.syncing
+  }
+
+  async drain(sessionId) {
+    const entry = this.entries.get(sessionId)
+    await entry?.queue
+    return this.status(sessionId)
+  }
+}

package/lib/index.js

@@ -33,6 +33,7 @@ export function createAgentClientPlugin(options = {}) {
         config,
         getTransport,
         options.recovery,
+        { scopeStore: options.scopeStore, archiveStore: options.archiveStore },
       ).install()
       ctx.provide('bailingHubAgentClient', runtime)
     },
@@ -44,6 +45,8 @@ export function apply(ctx, config) {
 }
 
 export { BailingHubAgentClientRuntime } from './runtime.js'
+export { createFileSessionScopeStore, createMemorySessionScopeStore } from './session-scope-store.js'
+export { createFileConversationArchiveStore, createMemoryConversationArchiveStore } from './conversation-archive-store.js'
 export {
   DEFAULT_SDK_MODULE,
   REQUIRED_METHODS,