@lota-sdk/core 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -16,7 +16,7 @@
     }
   },
   "scripts": {
-    "lint": "node ../node_modules/oxlint/bin/oxlint --fix -c ../oxlint.config.ts src",
+    "lint": "bunx oxlint --fix -c ../oxlint.config.ts src",
     "format": "bunx oxfmt src",
     "typecheck": "bunx tsgo --noEmit",
     "test:unit": "bun test ../tests/unit/core",
@@ -29,12 +29,15 @@
   "dependencies": {
     "@ai-sdk/devtools": "^0.0.15",
     "@ai-sdk/openai": "^3.0.48",
+    "@chat-adapter/slack": "^4.23.0",
+    "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.1.16",
+    "@lota-sdk/shared": "0.1.18",
     "@mendable/firecrawl-js": "^4.17.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.137",
     "bullmq": "^5.71.0",
+    "chat": "^4.23.0",
     "cron-parser": "^5.5.0",
     "hono": "^4.12.9",
     "ioredis": "5.9.3",

package/src/ai/definitions.ts

@@ -283,7 +283,7 @@ export const generalRule = defineRule({
   name: 'general',
   instructions: `# General Rules
 
-- Be concise and direct.
+- Be concise and direct. Prefer short, direct responses. Do not pad with context the user did not ask for.
 - Follow the user's request and constraints.
 - Ask clarifying questions when necessary.
 - Be formal and professional when tone is unclear.

package/src/ai/embedding-cache.ts

@@ -1,10 +1,8 @@
-import { createHash } from 'node:crypto'
-
 import type IORedis from 'ioredis'
 
 import { aiLogger } from '../config/logger'
 
-export const DEFAULT_EMBEDDING_CACHE_TTL_SECONDS = 3600
+export const DEFAULT_EMBEDDING_CACHE_TTL_SECONDS = 7200
 const EMBEDDING_CACHE_KEY_PREFIX = 'emb'
 
 export class EmbeddingCache {
@@ -14,7 +12,7 @@ export class EmbeddingCache {
   ) {}
 
   private buildKey(model: string, text: string): string {
-    const hash = createHash('sha256').update(text).digest('hex')
+    const hash = new Bun.CryptoHasher('sha256').update(text).digest('hex')
     return `${EMBEDDING_CACHE_KEY_PREFIX}:${model}:${hash}`
   }
 

package/src/{bifrost/bifrost.ts → ai-gateway/ai-gateway.ts}

@@ -3,26 +3,57 @@ import { createOpenAI } from '@ai-sdk/openai'
 import { wrapLanguageModel } from 'ai'
 import type { LanguageModelMiddleware } from 'ai'
 
-import { getRequiredEnv } from '../utils/env'
+import { getRuntimeConfig } from '../runtime/runtime-config'
 import { isRecord, readString } from '../utils/string'
 
-type BifrostLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model']
-type BifrostExtraParams = Record<string, unknown>
-type BifrostChatResponse = { body?: unknown }
-type BifrostTransformParamsOptions = Parameters<NonNullable<LanguageModelMiddleware['transformParams']>>[0]
+type AiGatewayLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model']
+type AiGatewayExtraParams = Record<string, unknown>
+type AiGatewayChatResponse = { body?: unknown }
+type AiGatewayTransformParamsOptions = Parameters<NonNullable<LanguageModelMiddleware['transformParams']>>[0]
 type WrapStreamOptions = Parameters<NonNullable<LanguageModelMiddleware['wrapStream']>>[0]
-type BifrostCallOptions = WrapStreamOptions['params']
-type BifrostGenerateResult = Awaited<ReturnType<WrapStreamOptions['doGenerate']>>
-type BifrostStreamResult = Awaited<ReturnType<WrapStreamOptions['doStream']>>
-type BifrostGeneratedContent = BifrostGenerateResult['content'][number]
-type BifrostStreamPart = BifrostStreamResult['stream'] extends ReadableStream<infer T> ? T : never
-
+type AiGatewayCallOptions = WrapStreamOptions['params']
+type AiGatewayGenerateResult = Awaited<ReturnType<WrapStreamOptions['doGenerate']>>
+type AiGatewayStreamResult = Awaited<ReturnType<WrapStreamOptions['doStream']>>
+type AiGatewayGeneratedContent = AiGatewayGenerateResult['content'][number]
+type AiGatewayStreamPart = AiGatewayStreamResult['stream'] extends ReadableStream<infer T> ? T : never
+type AiGatewayConfig = { apiKey: string; baseURL: string }
+
+const EXPECTED_GATEWAY_KEY_PREFIX = 'sk-bf-'
+const AI_GATEWAY_VIRTUAL_KEY_HEADER = 'x-bf-vk'
+const AI_GATEWAY_EXTRA_PARAMS_HEADER = 'x-bf-passthrough-extra-params'
+const DEFAULT_AI_GATEWAY_URL = 'https://ai-gateway.gobrainy.ai' as const
 const OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS = {
   plugins: [{ id: 'response-healing' }],
-} as const satisfies BifrostExtraParams
+} as const satisfies AiGatewayExtraParams
+
+function normalizeAiGatewayUrl(value: string): string {
+  const trimmed = value.trim()
+  if (!trimmed) {
+    throw new Error('[ai-gateway] AI gateway URL is required.')
+  }
+
+  const normalized = trimmed.replace(/\/+$/, '')
+  return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`
+}
+
+function readDirectEnvAiGatewayConfig(): AiGatewayConfig {
+  const apiKey = (process.env.LOTA_KEY ?? process.env.VENTUROS_KEY ?? '').trim()
+  if (!apiKey) {
+    throw new Error(
+      '[ai-gateway] Missing AI gateway key. Set LOTA_KEY or VENTUROS_KEY, or configure createLotaRuntime({ aiGateway: { key } }).',
+    )
+  }
 
-function readRequiredGatewayEnv(name: 'AI_GATEWAY_KEY' | 'AI_GATEWAY_URL'): string {
-  return getRequiredEnv(name).trim()
+  return { apiKey, baseURL: normalizeAiGatewayUrl(process.env.AI_GATEWAY_URL?.trim() || DEFAULT_AI_GATEWAY_URL) }
+}
+
+function readAiGatewayConfig(): AiGatewayConfig {
+  try {
+    const { aiGateway } = getRuntimeConfig()
+    return { apiKey: aiGateway.key.trim(), baseURL: normalizeAiGatewayUrl(aiGateway.url) }
+  } catch {
+    return readDirectEnvAiGatewayConfig()
+  }
 }
 
 function readReasoningDetailsText(value: unknown): string | null {
@@ -41,7 +72,7 @@ function readReasoningDeltaText(value: unknown): string | null {
   return typeof value === 'string' && value.length > 0 ? value : null
 }
 
-function readBifrostChatReasoningText(message: Record<string, unknown>): string | null {
+function readAiGatewayChatReasoningText(message: Record<string, unknown>): string | null {
   return (
     readString(message.reasoning) ??
     readString(message.reasoning_content) ??
@@ -49,20 +80,20 @@ function readBifrostChatReasoningText(message: Record<string, unknown>): string
   )
 }
 
-export function extractBifrostChatReasoningText(responseBody: unknown): string | null {
+export function extractAiGatewayChatReasoningText(responseBody: unknown): string | null {
   if (!isRecord(responseBody) || !Array.isArray(responseBody.choices)) return null
 
   for (const choice of responseBody.choices) {
     if (!isRecord(choice) || !isRecord(choice.message)) continue
 
-    const reasoningText = readBifrostChatReasoningText(choice.message)
+    const reasoningText = readAiGatewayChatReasoningText(choice.message)
     if (reasoningText) return reasoningText
   }
 
   return null
 }
 
-export function extractBifrostChatReasoningDeltaText(rawChunk: unknown): string | null {
+export function extractAiGatewayChatReasoningDeltaText(rawChunk: unknown): string | null {
   if (!isRecord(rawChunk) || !Array.isArray(rawChunk.choices)) return null
 
   for (const choice of rawChunk.choices) {
@@ -78,9 +109,9 @@ export function extractBifrostChatReasoningDeltaText(rawChunk: unknown): string
   return null
 }
 
-type BifrostResponsesReasoningDelta = { id: string; delta: string; itemId: string }
+type AiGatewayResponsesReasoningDelta = { id: string; delta: string; itemId: string }
 
-export function extractBifrostResponsesReasoningDelta(rawChunk: unknown): BifrostResponsesReasoningDelta | null {
+export function extractAiGatewayResponsesReasoningDelta(rawChunk: unknown): AiGatewayResponsesReasoningDelta | null {
   if (!isRecord(rawChunk) || rawChunk.type !== 'response.reasoning_summary_text.delta') return null
   if ('summary_index' in rawChunk) return null
 
@@ -91,21 +122,21 @@ export function extractBifrostResponsesReasoningDelta(rawChunk: unknown): Bifros
   return { id: `${itemId}:0`, delta, itemId }
 }
 
-export function injectBifrostChatReasoningContent(
-  content: readonly BifrostGeneratedContent[],
-  response?: BifrostChatResponse,
-): BifrostGeneratedContent[] {
+export function injectAiGatewayChatReasoningContent(
+  content: readonly AiGatewayGeneratedContent[],
+  response?: AiGatewayChatResponse,
+): AiGatewayGeneratedContent[] {
   if (content.some((part) => part.type === 'reasoning')) {
     return [...content]
   }
 
-  const reasoningText = extractBifrostChatReasoningText(response?.body)
+  const reasoningText = extractAiGatewayChatReasoningText(response?.body)
   if (!reasoningText) return [...content]
 
   return [{ type: 'reasoning', text: reasoningText }, ...content]
 }
 
-function isReasoningEnabled(params: BifrostCallOptions): boolean {
+function isReasoningEnabled(params: AiGatewayCallOptions): boolean {
   if (!isRecord(params.providerOptions) || !isRecord(params.providerOptions.openai)) return false
 
   const openaiOptions = params.providerOptions.openai
@@ -114,34 +145,34 @@ function isReasoningEnabled(params: BifrostCallOptions): boolean {
   return typeof openaiOptions.reasoningEffort === 'string' && openaiOptions.reasoningEffort !== 'none'
 }
 
-function shouldCloseInjectedReasoning(chunk: BifrostStreamPart): boolean {
+function shouldCloseInjectedReasoning(chunk: AiGatewayStreamPart): boolean {
   return chunk.type !== 'stream-start' && chunk.type !== 'response-metadata' && chunk.type !== 'raw'
 }
 
-export function injectBifrostChatReasoningStream(
-  stream: ReadableStream<BifrostStreamPart>,
-): ReadableStream<BifrostStreamPart> {
-  const reasoningId = 'bifrost-reasoning-0'
+export function injectAiGatewayChatReasoningStream(
+  stream: ReadableStream<AiGatewayStreamPart>,
+): ReadableStream<AiGatewayStreamPart> {
+  const reasoningId = 'ai-gateway-reasoning-0'
   let reasoningOpen = false
   let reasoningClosed = false
 
   return stream.pipeThrough(
-    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
+    new TransformStream<AiGatewayStreamPart, AiGatewayStreamPart>({
       transform(chunk, controller) {
         const closeReasoning = () => {
           if (!reasoningOpen || reasoningClosed) return
 
-          controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies BifrostStreamPart)
+          controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies AiGatewayStreamPart)
           reasoningClosed = true
         }
 
         if (chunk.type === 'raw') {
-          const reasoningDelta = reasoningClosed ? null : extractBifrostChatReasoningDeltaText(chunk.rawValue)
+          const reasoningDelta = reasoningClosed ? null : extractAiGatewayChatReasoningDeltaText(chunk.rawValue)
           controller.enqueue(chunk)
 
           if (reasoningDelta) {
             if (!reasoningOpen) {
-              controller.enqueue({ type: 'reasoning-start', id: reasoningId } satisfies BifrostStreamPart)
+              controller.enqueue({ type: 'reasoning-start', id: reasoningId } satisfies AiGatewayStreamPart)
               reasoningOpen = true
             }
 
@@ -149,7 +180,7 @@ export function injectBifrostChatReasoningStream(
               type: 'reasoning-delta',
               id: reasoningId,
               delta: reasoningDelta,
-            } satisfies BifrostStreamPart)
+            } satisfies AiGatewayStreamPart)
           }
           return
         }
@@ -162,23 +193,23 @@ export function injectBifrostChatReasoningStream(
       },
       flush(controller) {
         if (!reasoningOpen || reasoningClosed) return
-        controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies BifrostStreamPart)
+        controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies AiGatewayStreamPart)
       },
     }),
   )
 }
 
-export function injectBifrostResponsesReasoningStream(
-  stream: ReadableStream<BifrostStreamPart>,
-): ReadableStream<BifrostStreamPart> {
+export function injectAiGatewayResponsesReasoningStream(
+  stream: ReadableStream<AiGatewayStreamPart>,
+): ReadableStream<AiGatewayStreamPart> {
   return stream.pipeThrough(
-    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
+    new TransformStream<AiGatewayStreamPart, AiGatewayStreamPart>({
       transform(chunk, controller) {
         controller.enqueue(chunk)
 
         if (chunk.type !== 'raw') return
 
-        const reasoningDelta = extractBifrostResponsesReasoningDelta(chunk.rawValue)
+        const reasoningDelta = extractAiGatewayResponsesReasoningDelta(chunk.rawValue)
         if (!reasoningDelta) return
 
         controller.enqueue({
@@ -186,16 +217,16 @@ export function injectBifrostResponsesReasoningStream(
           id: reasoningDelta.id,
           delta: reasoningDelta.delta,
           providerMetadata: { openai: { itemId: reasoningDelta.itemId } },
-        } satisfies BifrostStreamPart)
+        } satisfies AiGatewayStreamPart)
       },
     }),
   )
 }
 
-function addBifrostReasoningRawChunks(
-  params: BifrostCallOptions,
-  type: BifrostTransformParamsOptions['type'],
-): BifrostCallOptions {
+function addAiGatewayReasoningRawChunks(
+  params: AiGatewayCallOptions,
+  type: AiGatewayTransformParamsOptions['type'],
+): AiGatewayCallOptions {
   if (type !== 'stream' || !isReasoningEnabled(params) || params.includeRawChunks === true) {
     return params
   }
@@ -203,9 +234,9 @@ function addBifrostReasoningRawChunks(
   return { ...params, includeRawChunks: true }
 }
 
-export function injectBifrostExtraParamsRequestBody(
+export function injectAiGatewayExtraParamsRequestBody(
   body: BodyInit | null | undefined,
-  extraParams: BifrostExtraParams,
+  extraParams: AiGatewayExtraParams,
 ): BodyInit | null | undefined {
   if (typeof body !== 'string') return body
 
@@ -225,87 +256,90 @@ export function injectBifrostExtraParamsRequestBody(
   return JSON.stringify({ ...parsed, extra_params: mergedExtraParams })
 }
 
-function createBifrostFetchWithExtraParams(extraParams: BifrostExtraParams): typeof fetch {
+function createAiGatewayFetchWithExtraParams(extraParams: AiGatewayExtraParams): typeof fetch {
   const fetchWithExtraParams = (input: RequestInfo | URL, init?: RequestInit | BunFetchRequestInit) =>
-    globalThis.fetch(input, { ...init, body: injectBifrostExtraParamsRequestBody(init?.body, extraParams) })
+    globalThis.fetch(input, { ...init, body: injectAiGatewayExtraParamsRequestBody(init?.body, extraParams) })
 
   return Object.assign(fetchWithExtraParams, { preconnect: globalThis.fetch.preconnect.bind(globalThis.fetch) })
 }
 
-function createBifrostProvider(extraParams?: BifrostExtraParams) {
-  const apiKey = readRequiredGatewayEnv('AI_GATEWAY_KEY')
-  if (!apiKey.startsWith('sk-bf-')) {
-    throw new Error('[bifrost] AI_GATEWAY_KEY must use the Bifrost virtual-key format (sk-bf-*).')
+function createAiGatewayProvider(extraParams?: AiGatewayExtraParams) {
+  const { apiKey, baseURL } = readAiGatewayConfig()
+  if (!apiKey.startsWith(EXPECTED_GATEWAY_KEY_PREFIX)) {
+    throw new Error(`[ai-gateway] Gateway keys must use the ${EXPECTED_GATEWAY_KEY_PREFIX}* format.`)
   }
 
   return createOpenAI({
-    baseURL: readRequiredGatewayEnv('AI_GATEWAY_URL'),
+    baseURL,
     apiKey,
-    headers: { 'x-bf-vk': apiKey, ...(extraParams ? { 'x-bf-passthrough-extra-params': 'true' } : {}) },
-    ...(extraParams ? { fetch: createBifrostFetchWithExtraParams(extraParams) } : {}),
+    headers: {
+      [AI_GATEWAY_VIRTUAL_KEY_HEADER]: apiKey,
+      ...(extraParams ? { [AI_GATEWAY_EXTRA_PARAMS_HEADER]: 'true' } : {}),
+    },
+    ...(extraParams ? { fetch: createAiGatewayFetchWithExtraParams(extraParams) } : {}),
   })
 }
 
-function withBifrostDevTools<TModel extends BifrostLanguageModel>(model: TModel): TModel {
+function withAiGatewayDevTools<TModel extends AiGatewayLanguageModel>(model: TModel): TModel {
   return wrapLanguageModel({ model, middleware: devToolsMiddleware() }) as TModel
 }
 
 let provider: ReturnType<typeof createOpenAI> | null = null
 let openRouterResponseHealingProvider: ReturnType<typeof createOpenAI> | null = null
 
-export function getBifrostProvider() {
+export function getAiGatewayProvider() {
   if (provider) return provider
 
-  provider = createBifrostProvider()
+  provider = createAiGatewayProvider()
 
   return provider
 }
 
-export function getBifrostOpenRouterResponseHealingProvider() {
+export function getAiGatewayOpenRouterResponseHealingProvider() {
   if (openRouterResponseHealingProvider) return openRouterResponseHealingProvider
 
-  openRouterResponseHealingProvider = createBifrostProvider(OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS)
+  openRouterResponseHealingProvider = createAiGatewayProvider(OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS)
 
   return openRouterResponseHealingProvider
 }
 
-export function bifrostModel(modelId: string) {
-  return withBifrostDevTools(
+export function aiGatewayModel(modelId: string) {
+  return withAiGatewayDevTools(
     wrapLanguageModel({
-      model: getBifrostProvider()(modelId),
+      model: getAiGatewayProvider()(modelId),
       middleware: {
         specificationVersion: 'v3',
-        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
+        transformParams: async ({ params, type }) => addAiGatewayReasoningRawChunks(params, type),
         wrapStream: async ({ doStream, params }) => {
           const result = await doStream()
           if (!isReasoningEnabled(params)) return result
 
-          return { ...result, stream: injectBifrostResponsesReasoningStream(result.stream) }
+          return { ...result, stream: injectAiGatewayResponsesReasoningStream(result.stream) }
         },
       },
     }),
   )
 }
 
-export function bifrostOpenRouterResponseHealingModel(modelId: string) {
-  return withBifrostDevTools(getBifrostOpenRouterResponseHealingProvider()(modelId))
+export function aiGatewayOpenRouterResponseHealingModel(modelId: string) {
+  return withAiGatewayDevTools(getAiGatewayOpenRouterResponseHealingProvider()(modelId))
 }
 
-export function bifrostChatModel(modelId: string) {
-  return withBifrostDevTools(
+export function aiGatewayChatModel(modelId: string) {
+  return withAiGatewayDevTools(
     wrapLanguageModel({
-      model: getBifrostProvider().chat(modelId),
+      model: getAiGatewayProvider().chat(modelId),
       middleware: {
         specificationVersion: 'v3',
-        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
+        transformParams: async ({ params, type }) => addAiGatewayReasoningRawChunks(params, type),
         wrapGenerate: async ({ doGenerate }) => {
           const result = await doGenerate()
 
           return {
             ...result,
-            content: injectBifrostChatReasoningContent(
+            content: injectAiGatewayChatReasoningContent(
               result.content,
-              result.response as BifrostChatResponse | undefined,
+              result.response as AiGatewayChatResponse | undefined,
             ),
           }
         },
@@ -313,13 +347,15 @@ export function bifrostChatModel(modelId: string) {
           const result = await doStream()
           if (!isReasoningEnabled(params)) return result
 
-          return { ...result, stream: injectBifrostChatReasoningStream(result.stream) }
+          return { ...result, stream: injectAiGatewayChatReasoningStream(result.stream) }
         },
       },
     }),
   )
 }
 
-export function bifrostEmbeddingModel(modelId: string) {
-  return getBifrostProvider().embeddingModel(modelId)
+export function aiGatewayEmbeddingModel(modelId: string) {
+  return getAiGatewayProvider().embeddingModel(modelId)
 }
+
+export { DEFAULT_AI_GATEWAY_URL, normalizeAiGatewayUrl }

package/src/ai-gateway/cache-headers.ts

@@ -0,0 +1,8 @@
+const AI_GATEWAY_CACHE_KEY_HEADER = 'x-bf-cache-key'
+const AI_GATEWAY_CACHE_TTL_HEADER = 'x-bf-cache-ttl'
+
+export function buildAiGatewayCacheHeaders(cacheKey: string, ttl?: string): Record<string, string> {
+  const headers: Record<string, string> = { [AI_GATEWAY_CACHE_KEY_HEADER]: cacheKey }
+  if (ttl) headers[AI_GATEWAY_CACHE_TTL_HEADER] = ttl
+  return headers
+}

package/src/ai-gateway/index.ts

@@ -0,0 +1,2 @@
+export * from './ai-gateway'
+export * from './cache-headers'

package/src/config/model-constants.ts

@@ -1,5 +1,5 @@
 export {
-  BIFROST_REASONING_SUMMARY_LEVEL,
+  AI_GATEWAY_REASONING_SUMMARY_LEVEL,
   OPENAI_HIGH_REASONING_PROVIDER_OPTIONS,
   OPENAI_REASONING_MODEL_ID,
   OPENROUTER_DELEGATED_REASONING_MODEL_ID,

package/src/create-runtime.ts

@@ -25,6 +25,8 @@ import type { LotaRuntimeConfig, ResolvedLotaRuntimeConfig } from './runtime/run
 import { configureRuntimeExtensions } from './runtime/runtime-extensions'
 import type { LotaRuntimeWorkers } from './runtime/runtime-worker-registry'
 import { buildRuntimeWorkerRegistry } from './runtime/runtime-worker-registry'
+import type { LotaRuntimeSocialChat } from './runtime/social-chat'
+import { createSocialChatRuntime } from './runtime/social-chat'
 import type { attachmentService } from './services/attachment.service'
 import { attachmentService as attachmentServiceSingleton } from './services/attachment.service'
 import { coordinationRegistryService as coordinationRegistryServiceSingleton } from './services/coordination-registry.service'
@@ -47,6 +49,10 @@ import type { recentActivityTitleService } from './services/recent-activity-titl
 import { recentActivityTitleService as recentActivityTitleServiceSingleton } from './services/recent-activity-title.service'
 import type { recentActivityService } from './services/recent-activity.service'
 import { recentActivityService as recentActivityServiceSingleton } from './services/recent-activity.service'
+import {
+  configureSocialChatHistory,
+  socialChatHistoryService as socialChatHistoryServiceSingleton,
+} from './services/social-chat-history.service'
 import { getBuiltInSystemExecutors } from './services/system-executor.service'
 import type { userService } from './services/user.service'
 import { userService as userServiceSingleton } from './services/user.service'
@@ -115,6 +121,7 @@ export interface LotaRuntime {
     userService: typeof userService
     recentActivityService: typeof recentActivityService
     recentActivityTitleService: typeof recentActivityTitleService
+    socialChatHistoryService: typeof socialChatHistoryServiceSingleton
     executionPlanService: typeof executionPlanService
     workstreamMessageService: typeof workstreamMessageService
     workstreamService: typeof workstreamService
@@ -184,6 +191,7 @@ export interface LotaRuntime {
     closeConnection: () => Promise<void>
   }
   workers: LotaRuntimeWorkers
+  socialChat: LotaRuntimeSocialChat
   schemaFiles: Array<string | URL>
   contributions: { envKeys: readonly string[]; schemaFiles: Array<string | URL> }
   config: ResolvedLotaRuntimeConfig
@@ -218,11 +226,21 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     setRedisConnectionManager(redisManager)
     configureEmbeddingCache(redisManager.getConnection(), runtimeConfig.memory.embeddingCacheTtlSeconds)
     configureBackgroundProcessing(runtimeConfig.backgroundProcessing)
+    configureSocialChatHistory({ keyPrefix: runtimeConfig.socialChat?.historyRedisKeyPrefix })
+
+    const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
+    const socialChatAgentDisplayName = runtimeConfig.socialChat?.agentDisplayName?.trim() || 'Lota'
+    if (runtimeConfig.socialChat && !runtimeConfig.agents.roster.includes(socialChatAgentId)) {
+      throw new Error(`socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`)
+    }
+    const agentDisplayNames = runtimeConfig.socialChat
+      ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
+      : runtimeConfig.agents.displayNames
 
     configureAgents({
       roster: runtimeConfig.agents.roster,
       leadAgentId: runtimeConfig.agents.leadAgentId,
-      displayNames: runtimeConfig.agents.displayNames,
+      displayNames: agentDisplayNames,
       shortDisplayNames: runtimeConfig.agents.shortDisplayNames,
       teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
       getCoreWorkstreamProfile: runtimeConfig.agents.getCoreWorkstreamProfile,
@@ -264,6 +282,10 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     const contributionEnvKeys = [...LOTA_RUNTIME_ENV_KEYS, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
     const connectPluginDatabases = createPluginDatabaseConnector(pluginRuntime)
     const workers = buildRuntimeWorkerRegistry(runtimeConfig.extraWorkers)
+    const socialChat = createSocialChatRuntime({
+      redisClient: redisManager.getConnection(),
+      socialChat: runtimeConfig.socialChat,
+    })
 
     const lota = {
       organizations: {
@@ -369,6 +391,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         userService: userServiceSingleton,
         recentActivityService: recentActivityServiceSingleton,
         recentActivityTitleService: recentActivityTitleServiceSingleton,
+        socialChatHistoryService: socialChatHistoryServiceSingleton,
         executionPlanService: executionPlanServiceSingleton,
         workstreamMessageService: workstreamMessageServiceSingleton,
         workstreamService: workstreamServiceSingleton,
@@ -388,6 +411,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         closeConnection: async () => await redisManager.closeConnection(),
       },
       workers,
+      socialChat,
       schemaFiles,
       contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
       config: runtimeConfig,
@@ -412,6 +436,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         disconnected = true
 
         try {
+          await socialChat.shutdown()
           await closeSharedSubscriber()
           await db.disconnect()
           await redisManager.closeConnection()

package/src/db/memory-store.helpers.ts

@@ -1,5 +1,3 @@
-import { createHash } from 'node:crypto'
-
 import type { BasicSearchRow, SurrealMemoryRow } from './memory-store.rows'
 import type { MemoryRecord, MemorySearchResult } from './memory-types'
 import { recordIdToString } from './record-id'
@@ -114,5 +112,5 @@ export function processGraphAwareRows<T extends BasicSearchRow>(
 }
 
 export function hashContent(content: string, scopeId: string, memoryType: string): string {
-  return createHash('sha256').update(`${scopeId}:${memoryType}:${content}`).digest('hex')
+  return new Bun.CryptoHasher('sha256').update(`${scopeId}:${memoryType}:${content}`).digest('hex')
 }

package/src/db/schema-fingerprint.ts

@@ -1,11 +1,9 @@
-import { createHash } from 'node:crypto'
-
 function toSchemaFilePath(value: string | URL): string {
   return value instanceof URL ? value.pathname : value
 }
 
 export async function computeSchemaFingerprint(schemaFiles: readonly (string | URL)[]): Promise<string> {
-  const hash = createHash('sha256')
+  const hash = new Bun.CryptoHasher('sha256')
 
   // Sequential reads required: hash must be computed in deterministic file order
   for (const schemaFile of schemaFiles) {

package/src/embeddings/provider.ts

@@ -1,7 +1,7 @@
 import { embed, embedMany } from 'ai'
 
+import { aiGatewayEmbeddingModel } from '../ai-gateway/ai-gateway'
 import { getEmbeddingCache } from '../ai/embedding-cache'
-import { bifrostEmbeddingModel } from '../bifrost/bifrost'
 import { getRuntimeConfig } from '../runtime/runtime-config'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
@@ -30,7 +30,7 @@ function resolveEmbeddingModel(modelId: string) {
     )
   }
 
-  return bifrostEmbeddingModel(normalized)
+  return aiGatewayEmbeddingModel(normalized)
 }
 
 function normalizeEmbedding(embedding: readonly number[]): number[] {

package/src/index.ts

@@ -1,6 +1,6 @@
 export * from './create-runtime'
 export * from './ai'
-export * from './bifrost'
+export * from './ai-gateway'
 export * from './config'
 export * from './db'
 export * from './document'

package/src/queues/document-processor.queue.ts

@@ -1,5 +1,3 @@
-import { createHash } from 'node:crypto'
-
 import { Queue, Worker } from 'bullmq'
 import type IORedis from 'ioredis'
 
@@ -43,7 +41,7 @@ export function buildDocumentProcessorJobId(
     'orgId' | 'source' | 'sourceId' | 'sourceCanonicalKey' | 'sourceVersionKey' | 'title'
   >,
 ): string {
-  const digest = createHash('sha256')
+  const digest = new Bun.CryptoHasher('sha256')
     .update(
       JSON.stringify({
         orgId: job.orgId,
@@ -73,7 +71,7 @@ export function createDocumentProcessorQueueRuntime<TJob extends DocumentProcess
 } {
   const queueName = params.queueName ?? DEFAULT_DOCUMENT_PROCESSOR_QUEUE
   const workerName = params.workerName ?? DEFAULT_WORKER_NAME
-  const concurrency = params.concurrency ?? 4
+  const concurrency = params.concurrency ?? 10
   const lockDuration = params.lockDuration ?? 300_000
   const jobName = 'process-document' as Parameters<Queue<TJob, unknown, string>['add']>[0]
   const toQueueData = (job: TJob): Parameters<Queue<TJob, unknown, string>['add']>[1] =>