@lota-sdk/core 0.1.5

package/src/runtime/agent-prompt-context.ts

@@ -0,0 +1,119 @@
+import { toOptionalIsoDateTimeString } from '../utils/date-time'
+
+type StructuredProfile = Record<string, unknown>
+
+interface AgentPromptContext {
+  systemWorkspaceDetails: string
+}
+
+interface DomainEventLike {
+  actor?: string
+  action?: string
+  category?: string
+  significance?: string
+  summary?: string
+  createdAt?: unknown
+}
+
+interface BuildAgentPromptContextParams {
+  workspaceName?: string
+  summaryBlock?: string
+  structuredProfile?: StructuredProfile
+  promptSummary?: string
+  userName?: string | null
+  recentDomainEvents: DomainEventLike[]
+}
+
+function normalizeSummaryBlock(block?: string): string {
+  const normalized = block?.trim()
+  return normalized && normalized.length > 0 ? normalized : 'No workspace profile summary has been recorded yet.'
+}
+
+function normalizeUserName(name?: string | null): string {
+  const normalized = name?.trim()
+  return normalized && normalized.length > 0 ? normalized : 'Unknown'
+}
+
+function normalizeWorkspaceName(name?: string): string {
+  const normalized = name?.trim()
+  return normalized && normalized.length > 0 ? normalized : 'Workspace'
+}
+
+function hasStructuredProfileData(profile?: StructuredProfile): boolean {
+  return Boolean(profile && Object.keys(profile).length > 0)
+}
+
+function formatStructuredProfile(profile?: StructuredProfile): string {
+  if (!hasStructuredProfileData(profile)) {
+    return 'No structured workspace profile has been recorded yet.'
+  }
+
+  return JSON.stringify(profile, null, 2)
+}
+
+function formatDomainEvent(event: DomainEventLike, index: number): string {
+  const summary = typeof event.summary === 'string' && event.summary.trim().length > 0 ? event.summary.trim() : null
+  if (summary) {
+    const createdAt = toOptionalIsoDateTimeString(event.createdAt)
+    return createdAt ? `${index + 1}. ${summary} | createdAt=${createdAt}` : `${index + 1}. ${summary}`
+  }
+
+  const createdAt = toOptionalIsoDateTimeString(event.createdAt)
+  const segments = [`${index + 1}.`]
+  if (typeof event.actor === 'string' && event.actor.trim().length > 0) {
+    segments.push(`actor=${event.actor}`)
+  }
+  if (typeof event.action === 'string' && event.action.trim().length > 0) {
+    segments.push(`action=${event.action}`)
+  }
+  if (typeof event.category === 'string' && event.category.trim().length > 0) {
+    segments.push(`category=${event.category}`)
+  }
+  if (typeof event.significance === 'string' && event.significance.trim().length > 0) {
+    segments.push(`significance=${event.significance}`)
+  }
+
+  if (createdAt) {
+    segments.push(`createdAt=${createdAt}`)
+  }
+
+  if (segments.length === 1) {
+    segments.push('No structured event details.')
+  }
+
+  return segments.join(' | ')
+}
+
+function formatRecentDomainEvents(events: DomainEventLike[]): string {
+  if (events.length === 0) {
+    return 'No domain events recorded yet.'
+  }
+
+  return events.map((event, index) => formatDomainEvent(event, index)).join('\n')
+}
+
+export function buildAgentPromptContext(params: BuildAgentPromptContextParams): AgentPromptContext {
+  const workspaceName = normalizeWorkspaceName(params.workspaceName)
+  const summaryBlock = normalizeSummaryBlock(params.summaryBlock)
+  const structuredProfile = formatStructuredProfile(params.structuredProfile)
+  const promptSummary = params.promptSummary?.trim()
+  const userName = normalizeUserName(params.userName)
+  const recentDomainEvents = formatRecentDomainEvents(params.recentDomainEvents)
+
+  const workspaceDetailsBlock = [
+    '<workspace-profile>',
+    `name=${workspaceName}`,
+    'summary-block:',
+    summaryBlock,
+    'structured-profile-json:',
+    structuredProfile,
+    ...(promptSummary ? ['prompt-summary:', promptSummary] : []),
+    '</workspace-profile>',
+  ].join('\n')
+
+  const userDetailsBlock = ['<user-details>', `name=${userName}`, '</user-details>'].join('\n')
+
+  const domainEventsBlock = ['<domain-events>', 'last=5', recentDomainEvents, '</domain-events>'].join('\n')
+
+  return { systemWorkspaceDetails: [workspaceDetailsBlock, userDetailsBlock, domainEventsBlock].join('\n\n') }
+}

package/src/runtime/agent-runtime-policy.ts

@@ -0,0 +1,192 @@
+import type { ChatMode } from './agent-types'
+import { resolveReasoningProfile } from './workstream-routing-policy'
+import type { ReasoningProfileName } from './workstream-routing-policy'
+
+export interface AgentRuntimeConfig<TAgent extends string> {
+  id: TAgent
+  displayName: string
+  mode: ChatMode
+  extraInstructions?: string
+  maxSteps: number
+  reasoningProfile: ReasoningProfileName
+  toolCallBudget: number
+  maxInputTokensHint: number
+}
+
+export interface AgentToolPolicy<TSkill extends PropertyKey> {
+  resolvedMode: ChatMode
+  skills: TSkill[]
+  includeMemorySearch: boolean
+  includeConversationSearch: boolean
+  includeMemoryRemember: boolean
+  includeOrgActionSearch: boolean
+  includeMemoryBlockAppend: boolean
+  includeReadFileParts: boolean
+  includeInspectWebsite: boolean
+  includeProceedInOnboarding: boolean
+  includeGithubIntegration: boolean
+  includeIndexRepositoryByURL: boolean
+  includeIndexedRepository: boolean
+}
+
+export function toChatMode(workstreamMode: 'direct' | 'group'): ChatMode {
+  return workstreamMode === 'direct' ? 'fixedWorkstreamMode' : 'workstreamMode'
+}
+
+function toMemoryBlockSection(memoryBlock: string | undefined): string | undefined {
+  if (memoryBlock === undefined) return undefined
+  const content = memoryBlock.trim()
+  return ['<memory-block>', content, '</memory-block>'].join('\n')
+}
+
+export function resolveActiveAgentSkills<TAgent extends string, TSkill extends PropertyKey>(params: {
+  agentId: TAgent
+  workstreamMode: 'direct' | 'group'
+  mode?: ChatMode
+  onboardingActive: boolean
+  linearInstalled: boolean
+  getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
+}): TSkill[] {
+  const mode = params.mode ?? toChatMode(params.workstreamMode)
+  const baseSkills = params
+    .getAgentSkills(params.agentId, mode)
+    .filter((skill) => (params.linearInstalled ? true : skill !== ('linear' as TSkill)))
+
+  if (!params.onboardingActive) {
+    return baseSkills
+  }
+
+  if (params.agentId !== ('chief' as TAgent)) {
+    return []
+  }
+
+  return baseSkills.filter((skill) => skill === ('asking-user-questions' as TSkill))
+}
+
+export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends PropertyKey>(params: {
+  agentId: TAgent
+  displayNameByAgent: Record<TAgent, string>
+  workstreamMode: 'direct' | 'group'
+  mode?: ChatMode
+  skills?: TSkill[]
+  onboardingActive: boolean
+  linearInstalled: boolean
+  reasoningProfile?: ReasoningProfileName
+  systemWorkspaceDetails?: string
+  preSeededMemoriesSection?: string
+  retrievedKnowledgeSection?: string
+  workstreamMemoryBlock?: string
+  workstreamStateSection?: string
+  responseGuardSection?: string
+  learnedSkillsSection?: string
+  additionalInstructionSections?: string[]
+  getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
+  buildGlobalRuleInstructionSection: () => string
+  buildSkillInstructionSection: (skills: TSkill[]) => string
+  buildOnboardingPromptSection: () => string
+}): AgentRuntimeConfig<TAgent> {
+  const mode = params.mode ?? toChatMode(params.workstreamMode)
+  const profile = resolveReasoningProfile({ message: '', explicitProfile: params.reasoningProfile ?? 'standard' })
+  const rulesSection = params.buildGlobalRuleInstructionSection()
+  const skillsSection =
+    params.skills && params.skills.length > 0 ? params.buildSkillInstructionSection(params.skills) : ''
+  const onboardingPromptSection = params.onboardingActive ? params.buildOnboardingPromptSection() : ''
+  const instructionSections = [
+    rulesSection,
+    skillsSection,
+    params.learnedSkillsSection?.trim(),
+    onboardingPromptSection,
+    params.systemWorkspaceDetails?.trim(),
+    params.preSeededMemoriesSection?.trim(),
+    params.retrievedKnowledgeSection?.trim(),
+    toMemoryBlockSection(params.workstreamMemoryBlock),
+    params.workstreamStateSection?.trim(),
+    ...(params.additionalInstructionSections?.map((section) => section.trim()) ?? []),
+    params.responseGuardSection?.trim(),
+    params.onboardingActive ? 'Onboarding is active. Keep responses onboarding-focused and concise.' : undefined,
+  ].filter((value): value is string => Boolean(value && value.length > 0))
+  const extraInstructions = instructionSections.length > 0 ? instructionSections.join('\n\n') : undefined
+
+  return {
+    id: params.agentId,
+    displayName: params.displayNameByAgent[params.agentId] ?? params.agentId,
+    mode,
+    extraInstructions,
+    maxSteps: profile.maxSteps,
+    reasoningProfile: profile.name,
+    toolCallBudget: profile.toolCallBudget,
+    maxInputTokensHint: profile.maxInputTokensHint,
+  }
+}
+
+export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill extends PropertyKey>(params: {
+  agentId: TAgent
+  workstreamMode: 'direct' | 'group'
+  mode?: ChatMode
+  onboardingActive: boolean
+  linearInstalled: boolean
+  githubInstalled: boolean
+  provideRepoTool: boolean
+  getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
+}): AgentToolPolicy<TSkill> {
+  const resolvedMode = params.mode ?? toChatMode(params.workstreamMode)
+  const skills = resolveActiveAgentSkills({
+    agentId: params.agentId,
+    workstreamMode: params.workstreamMode,
+    mode: resolvedMode,
+    onboardingActive: params.onboardingActive,
+    linearInstalled: params.linearInstalled,
+    getAgentSkills: params.getAgentSkills,
+  })
+
+  return {
+    resolvedMode,
+    skills,
+    includeMemorySearch: !params.onboardingActive,
+    includeConversationSearch: !params.onboardingActive,
+    includeMemoryRemember: !params.onboardingActive,
+    includeOrgActionSearch: !params.onboardingActive,
+    includeMemoryBlockAppend: true,
+    includeReadFileParts: true,
+    includeInspectWebsite: params.onboardingActive && params.agentId === ('chief' as TAgent),
+    includeProceedInOnboarding: params.onboardingActive && params.agentId === ('chief' as TAgent),
+    includeGithubIntegration: params.onboardingActive && params.agentId === ('chief' as TAgent),
+    includeIndexRepositoryByURL: params.onboardingActive && params.agentId === ('chief' as TAgent),
+    includeIndexedRepository: params.githubInstalled && params.provideRepoTool,
+  }
+}
+
+export function buildTeamConsultationAgentToolPolicy<TAgent extends string, TSkill extends PropertyKey>(params: {
+  agentId: TAgent
+  blockedSkills: readonly TSkill[]
+  blockedToolNames: readonly string[]
+  githubInstalled: boolean
+  provideRepoTool: boolean
+  getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
+}): AgentToolPolicy<TSkill> & { blockedToolNames: Set<string> } {
+  const skills = resolveActiveAgentSkills({
+    agentId: params.agentId,
+    workstreamMode: 'group',
+    mode: 'fixedWorkstreamMode',
+    onboardingActive: false,
+    linearInstalled: false,
+    getAgentSkills: params.getAgentSkills,
+  }).filter((skill) => !params.blockedSkills.includes(skill))
+
+  return {
+    resolvedMode: 'fixedWorkstreamMode',
+    skills,
+    includeMemorySearch: true,
+    includeConversationSearch: true,
+    includeMemoryRemember: false,
+    includeOrgActionSearch: true,
+    includeMemoryBlockAppend: false,
+    includeReadFileParts: true,
+    includeInspectWebsite: false,
+    includeProceedInOnboarding: false,
+    includeGithubIntegration: false,
+    includeIndexRepositoryByURL: false,
+    includeIndexedRepository: params.githubInstalled && params.provideRepoTool,
+    blockedToolNames: new Set(params.blockedToolNames),
+  }
+}

package/src/runtime/agent-stream-helpers.ts

@@ -0,0 +1,117 @@
+import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
+
+import { agentDisplayNames } from '../config/agent-defaults'
+
+export function readFiniteNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+export function readRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined
+}
+
+export function readOpenRouterUsageCost(usage: LanguageModelUsage): { cost?: number; upstreamInferenceCost?: number } {
+  const rawUsage = readRecord(usage.raw)
+  if (!rawUsage) return {}
+
+  const cost = readFiniteNumber(rawUsage.cost)
+  const costDetails = readRecord(rawUsage.cost_details)
+  const upstreamInferenceCost = readFiniteNumber(costDetails?.upstream_inference_cost)
+
+  return {
+    ...(cost !== undefined ? { cost } : {}),
+    ...(upstreamInferenceCost !== undefined ? { upstreamInferenceCost } : {}),
+  }
+}
+
+export function createAgentMessageMetadata(params: {
+  agentId: string
+  agentName: string
+}): NonNullable<UIMessageStreamOptions<ChatMessage>['messageMetadata']> {
+  return ({ part }) => {
+    if (part.type === 'start') {
+      return { agentId: params.agentId, agentName: params.agentName, createdAt: Date.now() }
+    }
+
+    if (part.type === 'finish') {
+      const usageCost = readOpenRouterUsageCost(part.totalUsage)
+      return {
+        finishReason: part.finishReason,
+        ...(part.totalUsage.inputTokens !== undefined ? { inputTokens: part.totalUsage.inputTokens } : {}),
+        ...(part.totalUsage.outputTokens !== undefined ? { outputTokens: part.totalUsage.outputTokens } : {}),
+        ...(part.totalUsage.totalTokens !== undefined ? { totalTokens: part.totalUsage.totalTokens } : {}),
+        ...usageCost,
+      }
+    }
+
+    return undefined
+  }
+}
+
+export function createServerRunAbortController(externalAbortSignal?: AbortSignal) {
+  const controller = new AbortController()
+  const abort = (reason?: unknown) => {
+    if (controller.signal.aborted) return
+    controller.abort(reason ?? new DOMException('Run stopped by user.', 'AbortError'))
+  }
+
+  const abortFromExternal = () => {
+    abort((externalAbortSignal as (AbortSignal & { reason?: unknown }) | undefined)?.reason)
+  }
+
+  if (externalAbortSignal) {
+    if (externalAbortSignal.aborted) {
+      abortFromExternal()
+    } else {
+      externalAbortSignal.addEventListener('abort', abortFromExternal, { once: true })
+    }
+  }
+
+  return {
+    controller,
+    signal: controller.signal,
+    abort,
+    dispose: () => {
+      if (!externalAbortSignal) return
+      externalAbortSignal.removeEventListener('abort', abortFromExternal)
+    },
+  }
+}
+
+export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: number) {
+  const controller = new AbortController()
+  let didTimeout = false
+  const abortFromParent = () => {
+    controller.abort((parentSignal as AbortSignal & { reason?: unknown }).reason)
+  }
+  const timeoutId = setTimeout(() => {
+    didTimeout = true
+    controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
+  }, timeoutMs)
+
+  if (parentSignal.aborted) {
+    abortFromParent()
+  } else {
+    parentSignal.addEventListener('abort', abortFromParent, { once: true })
+  }
+
+  return {
+    signal: controller.signal,
+    didTimeout: () => didTimeout,
+    dispose: () => {
+      clearTimeout(timeoutId)
+      parentSignal.removeEventListener('abort', abortFromParent)
+    },
+  }
+}
+
+export function buildSpecialistTaskMessage(params: { agentId: string; task: string }): ChatMessage {
+  const displayName = agentDisplayNames[params.agentId] ?? params.agentId
+  return {
+    id: Bun.randomUUIDv7(),
+    role: 'user',
+    parts: [{ type: 'text', text: [`Chief of Staff request for ${displayName}:`, params.task.trim()].join('\n') }],
+    metadata: { createdAt: Date.now() },
+  }
+}

package/src/runtime/agent-types.ts

@@ -0,0 +1,22 @@
+import type { Output, PrepareStepFunction, StopCondition, ToolLoopAgentOnFinishCallback, ToolSet } from 'ai'
+
+export type ChatMode = 'direct' | 'workstreamMode' | 'fixedWorkstreamMode'
+
+export interface CreateRoutedAgentOptions<TTools extends ToolSet = ToolSet> {
+  mode: ChatMode
+  tools: TTools
+  extraInstructions?: string
+  stopWhen?: StopCondition<TTools> | Array<StopCondition<TTools>>
+  prepareStep?: PrepareStepFunction<TTools>
+  maxRetries?: number
+  modelOverride?: { model: unknown; providerOptions?: Record<string, unknown> }
+  onFinish?: ToolLoopAgentOnFinishCallback<TTools>
+}
+
+export interface CreateHelperToolLoopAgentOptions {
+  instructions?: string
+  maxOutputTokens?: number
+  temperature?: number
+  output?: Output.Output
+  maxRetries?: number
+}

package/src/runtime/approval-continuation.ts

@@ -0,0 +1,16 @@
+import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+
+export function hasApprovalRespondedParts(message: ChatMessage): boolean {
+  return message.parts.some((part) => 'state' in part && (part as { state: string }).state === 'approval-responded')
+}
+
+export function isApprovalContinuationRequest(messages: ChatMessage[]): boolean {
+  const lastAssistant = [...messages].reverse().find((message) => message.role === 'assistant')
+  if (!lastAssistant) return false
+
+  const lastMessageIndex = messages.lastIndexOf(lastAssistant)
+  const hasUserAfter = messages.slice(lastMessageIndex + 1).some((message) => message.role === 'user')
+  if (hasUserAfter) return false
+
+  return hasApprovalRespondedParts(lastAssistant)
+}

package/src/runtime/chat-attachments.ts

@@ -0,0 +1,46 @@
+import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+
+import type { ReadableUploadMetadataLike } from './chat-types'
+export type { ReadableUploadMetadataLike } from './chat-types'
+
+export function buildReadableUploadMetadataText(uploads: ReadableUploadMetadataLike[]): string {
+  if (uploads.length === 0) return ''
+
+  const lines = uploads.map((upload) => {
+    const sizeSegment = upload.sizeBytes === null ? '' : `, sizeBytes=${upload.sizeBytes}`
+    return `- ${upload.filename} (${upload.mediaType}${sizeSegment}) storageKey=${upload.storageKey}`
+  })
+
+  return [
+    'Uploaded files are available via tool readFileParts.',
+    'Call readFileParts with storageKey and part. Each part contains up to 25 pages.',
+    'Available uploads:',
+    ...lines,
+  ].join('\n')
+}
+
+export function buildModelInputMessagesWithUploadMetadata(params: {
+  messages: ChatMessage[]
+  latestUserMessageId: string
+  uploadMetadataText: string
+}): ChatMessage[] {
+  return params.messages.map((message) => {
+    const fileParts = message.parts.filter((part) => part.type === 'file')
+    if (fileParts.length === 0) return message
+
+    const nonFileParts = message.parts.filter((part) => part.type !== 'file')
+    const attachmentNames = fileParts
+      .map((part) => (typeof part.filename === 'string' && part.filename.trim() ? part.filename.trim() : 'Attachment'))
+      .join(', ')
+
+    const nextParts: ChatMessage['parts'] = [...nonFileParts]
+    if (attachmentNames) {
+      nextParts.push({ type: 'text', text: `User attached files: ${attachmentNames}` })
+    }
+    if (message.id === params.latestUserMessageId && params.uploadMetadataText) {
+      nextParts.push({ type: 'text', text: params.uploadMetadataText })
+    }
+
+    return { ...message, parts: nextParts }
+  })
+}

package/src/runtime/chat-message.ts

@@ -0,0 +1,10 @@
+import type { MessagePartLike } from './chat-types'
+
+export function hasMessageContent(parts: readonly MessagePartLike[]): boolean {
+  for (const part of parts) {
+    if (part.type === 'file') return true
+    if (part.type === 'text' && typeof part.text === 'string' && part.text.trim().length > 0) return true
+  }
+
+  return false
+}

package/src/runtime/chat-request-routing.ts

@@ -0,0 +1,21 @@
+import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+
+import { isApprovalContinuationRequest } from './approval-continuation'
+
+export type RoutedChatRequest =
+  | { kind: 'approval-continuation'; approvalMessages: ChatMessage[] }
+  | { kind: 'turn'; inputMessage: ChatMessage }
+  | { kind: 'invalid'; message: string }
+
+export function routeWorkstreamChatMessages(messages: ChatMessage[]): RoutedChatRequest {
+  if (isApprovalContinuationRequest(messages)) {
+    return { kind: 'approval-continuation', approvalMessages: messages }
+  }
+
+  const inputMessage = [...messages].reverse().find((message) => message.role === 'user')
+  if (!inputMessage) {
+    return { kind: 'invalid', message: 'Only user messages can be submitted to this endpoint.' }
+  }
+
+  return { kind: 'turn', inputMessage }
+}

package/src/runtime/chat-run-orchestration.ts

@@ -0,0 +1,25 @@
+const COMPACTION_POLL_INTERVAL_MS = 200
+const COMPACTION_MAX_WAIT_MS = 120_000
+
+export async function waitForCompactionIfNeeded<TEntity>(params: {
+  entityId: string
+  entityLabel: string
+  loadEntity: () => Promise<TEntity>
+  isCompacting: (entity: TEntity) => boolean
+}): Promise<TEntity> {
+  let entity = await params.loadEntity()
+  if (!params.isCompacting(entity)) return entity
+
+  const deadline = Date.now() + COMPACTION_MAX_WAIT_MS
+  while (params.isCompacting(entity)) {
+    if (Date.now() > deadline) {
+      throw new Error(
+        `${params.entityLabel} ${params.entityId} compaction did not complete within ${COMPACTION_MAX_WAIT_MS}ms`,
+      )
+    }
+    await Bun.sleep(COMPACTION_POLL_INTERVAL_MS)
+    entity = await params.loadEntity()
+  }
+
+  return entity
+}

package/src/runtime/chat-run-registry.ts

@@ -0,0 +1,20 @@
+export class ChatRunRegistry {
+  private controllers = new Map<string, AbortController>()
+
+  register(runId: string, controller: AbortController): void {
+    this.controllers.set(runId, controller)
+  }
+
+  unregister(runId: string): void {
+    this.controllers.delete(runId)
+  }
+
+  stop(runId: string, reason?: unknown): boolean {
+    const controller = this.controllers.get(runId)
+    if (!controller) return false
+
+    this.controllers.delete(runId)
+    controller.abort(reason)
+    return true
+  }
+}

package/src/runtime/chat-types.ts

@@ -0,0 +1,18 @@
+export interface MessagePartLike {
+  type?: string
+  text?: string
+  [key: string]: unknown
+}
+
+export interface ChatMessageLike<TPart extends MessagePartLike = MessagePartLike> {
+  role: string
+  parts: TPart[]
+  metadata?: unknown
+}
+
+export interface ReadableUploadMetadataLike {
+  storageKey: string
+  filename: string
+  mediaType: string
+  sizeBytes: number | null
+}

package/src/runtime/context-compaction-constants.ts

@@ -0,0 +1,11 @@
+export const CONTEXT_COMPACTION_THRESHOLD_RATIO = 0.7
+export const CONTEXT_OUTPUT_RESERVE_TOKENS = 32_000
+export const CONTEXT_SAFETY_MARGIN_TOKENS = 8_000
+export const COMPACTION_CHUNK_MAX_CHARS = 120_000
+export const SUMMARY_ROLLUP_MAX_TOKENS = 80_000
+export const CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES = ['userQuestions', 'proceedInOnboarding'] as const
+export const CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES = ['linear'] as const
+export const MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES = 15
+export const MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES = 10
+export const CONTEXT_SIZE = 200_000
+export const WORKSTREAM_RAW_TAIL_MESSAGES = 6