@elevasis/core 0.7.0 → 0.8.0

package/src/operations/sessions/index.ts

@@ -1,26 +1,26 @@
-// Session classes are server-only - import from @repo/core/server
-// Only types are exported here for browser-safe access
-export type {
-  SessionTurnResult,
-  SessionTokenUsage,
-  CreateSessionParams,
-  ListSessionsFilters,
-  SessionRow,
-  SessionInsert,
-  ExecuteTurnRequest
-} from './types'
-
-// Export validation schemas
-export {
-  CreateSessionSchema,
-  ExecuteTurnSchema,
-  ListSessionsQuerySchema,
-  SessionIdParamSchema,
-  ExecutionIdParamsSchema,
-  WebSocketSessionTurnSchema,
-  UuidSchema,
-  type CreateSessionInput,
-  type ExecuteTurnInput,
-  type ListSessionsQuery,
-  type WebSocketSessionTurnMessage
-} from './api-schemas'
+// Session classes are server-only - import from @repo/core/server
+// Only types are exported here for browser-safe access
+export type {
+  SessionTurnResult,
+  SessionTokenUsage,
+  CreateSessionParams,
+  ListSessionsFilters,
+  SessionRow,
+  SessionInsert,
+  ExecuteTurnRequest
+} from './types'
+
+// Export validation schemas
+export {
+  CreateSessionSchema,
+  ExecuteTurnSchema,
+  ListSessionsQuerySchema,
+  SessionIdParamSchema,
+  ExecutionIdParamsSchema,
+  WebSocketSessionTurnSchema,
+  UuidSchema,
+  type CreateSessionInput,
+  type ExecuteTurnInput,
+  type ListSessionsQuery,
+  type WebSocketSessionTurnMessage
+} from './api-schemas'

package/src/operations/sessions/server/manager.ts

@@ -1,90 +1,90 @@
-import type { SupabaseClient } from '../../../supabase'
-import { Session } from './session'
-import type { CreateSessionParams, ListSessionsFilters } from '../types'
-
-export class SessionManager {
-  constructor(private db: SupabaseClient) {}
-
-  async create(params: CreateSessionParams): Promise<Session> {
-    const { resourceId, organizationId, userId, metadata, contextWindowSize } = params
-
-    const { data, error } = await this.db
-      .from('sessions')
-      .insert({
-        resource_id: resourceId,
-        organization_id: organizationId,
-        user_id: userId ?? null,
-        memory_snapshot: { sessionMemory: {}, history: [] },
-        metadata: (metadata as Record<string, never> | null) ?? null,
-        session_total_turns: 0,
-        ...(contextWindowSize !== undefined && { context_window_size: contextWindowSize })
-      })
-      .select()
-      .single()
-
-    if (error) {
-      throw new Error(`Failed to create session: ${error.message}`)
-    }
-
-    return new Session(this.db, data)
-  }
-
-  async get(sessionId: string, organizationId: string): Promise<Session | null> {
-    const { data, error } = await this.db
-      .from('sessions')
-      .select()
-      .eq('session_id', sessionId)
-      .eq('organization_id', organizationId)
-      .is('deleted_at', null)
-      .single()
-
-    if (error) {
-      if (error.code === 'PGRST116') {
-        return null // Not found
-      }
-      throw new Error(`Failed to get session: ${error.message}`)
-    }
-
-    return new Session(this.db, data)
-  }
-
-  async list(filters: ListSessionsFilters): Promise<Session[]> {
-    const { organizationId, userId, resourceId, limit = 50 } = filters
-
-    let query = this.db
-      .from('sessions')
-      .select()
-      .eq('organization_id', organizationId)
-      .is('deleted_at', null)
-      .order('created_at', { ascending: false })
-      .limit(limit)
-
-    if (userId) {
-      query = query.eq('user_id', userId)
-    }
-
-    if (resourceId) {
-      query = query.eq('resource_id', resourceId)
-    }
-
-    const { data, error } = await query
-
-    if (error) {
-      throw new Error(`Failed to list sessions: ${error.message}`)
-    }
-
-    return data.map((row) => new Session(this.db, row))
-  }
-
-  async delete(sessionId: string, organizationId: string): Promise<void> {
-    const { error } = await this.db
-      .from('sessions')
-      .update({ deleted_at: new Date().toISOString() })
-      .eq('session_id', sessionId)
-      .eq('organization_id', organizationId)
-
-    if (error) {
-      throw new Error(`Failed to delete session: ${error.message}`)
-    }
-  }
-}
+import type { SupabaseClient } from '../../../supabase'
+import { Session } from './session'
+import type { CreateSessionParams, ListSessionsFilters } from '../types'
+
+export class SessionManager {
+  constructor(private db: SupabaseClient) {}
+
+  async create(params: CreateSessionParams): Promise<Session> {
+    const { resourceId, organizationId, userId, metadata, contextWindowSize } = params
+
+    const { data, error } = await this.db
+      .from('sessions')
+      .insert({
+        resource_id: resourceId,
+        organization_id: organizationId,
+        user_id: userId ?? null,
+        memory_snapshot: { sessionMemory: {}, history: [] },
+        metadata: (metadata as Record<string, never> | null) ?? null,
+        session_total_turns: 0,
+        ...(contextWindowSize !== undefined && { context_window_size: contextWindowSize })
+      })
+      .select()
+      .single()
+
+    if (error) {
+      throw new Error(`Failed to create session: ${error.message}`)
+    }
+
+    return new Session(this.db, data)
+  }
+
+  async get(sessionId: string, organizationId: string): Promise<Session | null> {
+    const { data, error } = await this.db
+      .from('sessions')
+      .select()
+      .eq('session_id', sessionId)
+      .eq('organization_id', organizationId)
+      .is('deleted_at', null)
+      .single()
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null // Not found
+      }
+      throw new Error(`Failed to get session: ${error.message}`)
+    }
+
+    return new Session(this.db, data)
+  }
+
+  async list(filters: ListSessionsFilters): Promise<Session[]> {
+    const { organizationId, userId, resourceId, limit = 50 } = filters
+
+    let query = this.db
+      .from('sessions')
+      .select()
+      .eq('organization_id', organizationId)
+      .is('deleted_at', null)
+      .order('created_at', { ascending: false })
+      .limit(limit)
+
+    if (userId) {
+      query = query.eq('user_id', userId)
+    }
+
+    if (resourceId) {
+      query = query.eq('resource_id', resourceId)
+    }
+
+    const { data, error } = await query
+
+    if (error) {
+      throw new Error(`Failed to list sessions: ${error.message}`)
+    }
+
+    return data.map((row) => new Session(this.db, row))
+  }
+
+  async delete(sessionId: string, organizationId: string): Promise<void> {
+    const { error } = await this.db
+      .from('sessions')
+      .update({ deleted_at: new Date().toISOString() })
+      .eq('session_id', sessionId)
+      .eq('organization_id', organizationId)
+
+    if (error) {
+      throw new Error(`Failed to delete session: ${error.message}`)
+    }
+  }
+}

package/src/operations/sessions/server/session.ts

@@ -1,180 +1,180 @@
-import type { SupabaseClient, Json } from '../../../supabase'
-import type { ExecutionContext } from '../../../execution/engine/base/types'
-import type { AgentDefinition } from '../../../execution/engine/agent/core/types'
-import type { AgentMemory } from '../../../execution/engine/agent/memory/types'
-import type { SessionRow, SessionTurnResult } from '../types'
-import { createLLMAdapter } from '../../../execution/engine/llm/adapters/server/adapter-factory'
-
-export class Session {
-  constructor(
-    private db: SupabaseClient,
-    private data: SessionRow
-  ) {}
-
-  // Getters
-  get sessionId(): string {
-    return this.data.session_id
-  }
-
-  get organizationId(): string {
-    return this.data.organization_id
-  }
-
-  get userId(): string | null {
-    return this.data.user_id
-  }
-
-  get resourceId(): string {
-    return this.data.resource_id
-  }
-
-  get totalTurns(): number {
-    return this.data.session_total_turns ?? 0
-  }
-
-  get memorySnapshot(): AgentMemory {
-    return this.data.memory_snapshot as unknown as AgentMemory
-  }
-
-  get metadata(): Record<string, unknown> | null {
-    return this.data.metadata as Record<string, unknown> | null
-  }
-
-  /** Title derived from the first user message, stored in metadata */
-  get title(): string | null {
-    const meta = this.data.metadata as Record<string, unknown> | null
-    return (meta?.title as string) ?? null
-  }
-
-  get createdAt(): Date {
-    return new Date(this.data.created_at!)
-  }
-
-  get updatedAt(): Date {
-    return new Date(this.data.updated_at!)
-  }
-
-  get isEnded(): boolean {
-    return !!this.data.ended_at
-  }
-
-  get contextWindowSize(): number {
-    return this.data.context_window_size
-  }
-
-  /**
-   * Execute a turn in this session
-   *
-   * Uses database transaction with row-level lock to prevent concurrent turn execution.
-   * Pattern: Lock → Read → Validate → Execute → Save
-   *
-   * @param agentDefinition - Agent definition to execute
-   * @param input - Input for this turn
-   * @param context - Full execution context (including sessionTurnMessages if streaming)
-   * @returns Turn result with output and metadata
-   */
-  async executeTurn<TInput, TOutput>(
-    agentDefinition: AgentDefinition,
-    input: TInput,
-    context: ExecutionContext
-  ): Promise<SessionTurnResult<TOutput>> {
-    const turnStartTime = Date.now()
-
-    // NOTE: Using RPC to acquire row-level lock and get fresh state
-    // This ensures atomic lock acquisition for concurrent turn prevention
-    const { data, error } = await this.db.rpc('execute_session_turn', {
-      p_session_id: this.sessionId
-    })
-
-    if (error) {
-      throw new Error(`Failed to acquire session lock: ${error.message}`)
-    }
-
-    // Reload fresh state from lock result
-    const lockResult = (Array.isArray(data) ? data[0] : data) as unknown
-    if (!lockResult) {
-      throw new Error('Session not found')
-    }
-
-    this.data = lockResult as SessionRow
-
-    // Validate
-    if (this.isEnded) {
-      throw new Error('Cannot execute turn on ended session')
-    }
-
-    // Create agent instance (stateless, recreated per turn)
-    const { Agent } = await import('../../../execution/engine/agent/core/agent')
-    const agent = new Agent<TInput, TOutput>(agentDefinition, createLLMAdapter)
-
-    // Execute agent (preloadMemory callback will restore session memory)
-    const output = await agent.execute(input, context)
-
-    // Update state and persist
-    const snapshot = agent.getMemorySnapshot()
-    if (!snapshot) {
-      throw new Error('Agent did not produce memory snapshot')
-    }
-
-    // Complete turn (messages already persisted immediately via onMessageEvent)
-    await this.completeTurn(snapshot)
-
-    return {
-      sessionId: this.sessionId,
-      executionId: context.executionId,
-      turnNumber: this.data.session_total_turns ?? 0,
-      output,
-      duration: Date.now() - turnStartTime
-    }
-  }
-
-  /**
-   * End this session (marks as ended, prevents future turns)
-   */
-  async end(): Promise<void> {
-    this.data.ended_at = new Date().toISOString()
-    this.data.updated_at = new Date().toISOString()
-    await this.save()
-  }
-
-  /**
-   * Convert to JSON representation
-   */
-  toJSON(): SessionRow {
-    return { ...this.data }
-  }
-
-  /**
-   * Save current state to database
-   */
-  private async save(): Promise<void> {
-    const { error } = await this.db
-      .from('sessions')
-      .update({
-        memory_snapshot: this.data.memory_snapshot,
-        session_total_turns: this.data.session_total_turns,
-        updated_at: this.data.updated_at,
-        ended_at: this.data.ended_at
-      })
-      .eq('session_id', this.sessionId)
-
-    if (error) {
-      throw new Error(`Failed to save session: ${error.message}`)
-    }
-  }
-
-  /**
-   * Complete turn by updating session state
-   * Messages already persisted immediately via onMessageEvent callback
-   * @param snapshot - Agent memory snapshot
-   */
-  private async completeTurn(snapshot: AgentMemory): Promise<void> {
-    // Update session state
-    this.data.memory_snapshot = snapshot as unknown as Json
-    this.data.session_total_turns = (this.data.session_total_turns ?? 0) + 1
-    this.data.updated_at = new Date().toISOString()
-
-    // Persist session state (messages already in DB)
-    await this.save()
-  }
-}
+import type { SupabaseClient, Json } from '../../../supabase'
+import type { ExecutionContext } from '../../../execution/engine/base/types'
+import type { AgentDefinition } from '../../../execution/engine/agent/core/types'
+import type { AgentMemory } from '../../../execution/engine/agent/memory/types'
+import type { SessionRow, SessionTurnResult } from '../types'
+import { createLLMAdapter } from '../../../execution/engine/llm/adapters/server/adapter-factory'
+
+export class Session {
+  constructor(
+    private db: SupabaseClient,
+    private data: SessionRow
+  ) {}
+
+  // Getters
+  get sessionId(): string {
+    return this.data.session_id
+  }
+
+  get organizationId(): string {
+    return this.data.organization_id
+  }
+
+  get userId(): string | null {
+    return this.data.user_id
+  }
+
+  get resourceId(): string {
+    return this.data.resource_id
+  }
+
+  get totalTurns(): number {
+    return this.data.session_total_turns ?? 0
+  }
+
+  get memorySnapshot(): AgentMemory {
+    return this.data.memory_snapshot as unknown as AgentMemory
+  }
+
+  get metadata(): Record<string, unknown> | null {
+    return this.data.metadata as Record<string, unknown> | null
+  }
+
+  /** Title derived from the first user message, stored in metadata */
+  get title(): string | null {
+    const meta = this.data.metadata as Record<string, unknown> | null
+    return (meta?.title as string) ?? null
+  }
+
+  get createdAt(): Date {
+    return new Date(this.data.created_at!)
+  }
+
+  get updatedAt(): Date {
+    return new Date(this.data.updated_at!)
+  }
+
+  get isEnded(): boolean {
+    return !!this.data.ended_at
+  }
+
+  get contextWindowSize(): number {
+    return this.data.context_window_size
+  }
+
+  /**
+   * Execute a turn in this session
+   *
+   * Uses database transaction with row-level lock to prevent concurrent turn execution.
+   * Pattern: Lock → Read → Validate → Execute → Save
+   *
+   * @param agentDefinition - Agent definition to execute
+   * @param input - Input for this turn
+   * @param context - Full execution context (including sessionTurnMessages if streaming)
+   * @returns Turn result with output and metadata
+   */
+  async executeTurn<TInput, TOutput>(
+    agentDefinition: AgentDefinition,
+    input: TInput,
+    context: ExecutionContext
+  ): Promise<SessionTurnResult<TOutput>> {
+    const turnStartTime = Date.now()
+
+    // NOTE: Using RPC to acquire row-level lock and get fresh state
+    // This ensures atomic lock acquisition for concurrent turn prevention
+    const { data, error } = await this.db.rpc('execute_session_turn', {
+      p_session_id: this.sessionId
+    })
+
+    if (error) {
+      throw new Error(`Failed to acquire session lock: ${error.message}`)
+    }
+
+    // Reload fresh state from lock result
+    const lockResult = (Array.isArray(data) ? data[0] : data) as unknown
+    if (!lockResult) {
+      throw new Error('Session not found')
+    }
+
+    this.data = lockResult as SessionRow
+
+    // Validate
+    if (this.isEnded) {
+      throw new Error('Cannot execute turn on ended session')
+    }
+
+    // Create agent instance (stateless, recreated per turn)
+    const { Agent } = await import('../../../execution/engine/agent/core/agent')
+    const agent = new Agent<TInput, TOutput>(agentDefinition, createLLMAdapter)
+
+    // Execute agent (preloadMemory callback will restore session memory)
+    const output = await agent.execute(input, context)
+
+    // Update state and persist
+    const snapshot = agent.getMemorySnapshot()
+    if (!snapshot) {
+      throw new Error('Agent did not produce memory snapshot')
+    }
+
+    // Complete turn (messages already persisted immediately via onMessageEvent)
+    await this.completeTurn(snapshot)
+
+    return {
+      sessionId: this.sessionId,
+      executionId: context.executionId,
+      turnNumber: this.data.session_total_turns ?? 0,
+      output,
+      duration: Date.now() - turnStartTime
+    }
+  }
+
+  /**
+   * End this session (marks as ended, prevents future turns)
+   */
+  async end(): Promise<void> {
+    this.data.ended_at = new Date().toISOString()
+    this.data.updated_at = new Date().toISOString()
+    await this.save()
+  }
+
+  /**
+   * Convert to JSON representation
+   */
+  toJSON(): SessionRow {
+    return { ...this.data }
+  }
+
+  /**
+   * Save current state to database
+   */
+  private async save(): Promise<void> {
+    const { error } = await this.db
+      .from('sessions')
+      .update({
+        memory_snapshot: this.data.memory_snapshot,
+        session_total_turns: this.data.session_total_turns,
+        updated_at: this.data.updated_at,
+        ended_at: this.data.ended_at
+      })
+      .eq('session_id', this.sessionId)
+
+    if (error) {
+      throw new Error(`Failed to save session: ${error.message}`)
+    }
+  }
+
+  /**
+   * Complete turn by updating session state
+   * Messages already persisted immediately via onMessageEvent callback
+   * @param snapshot - Agent memory snapshot
+   */
+  private async completeTurn(snapshot: AgentMemory): Promise<void> {
+    // Update session state
+    this.data.memory_snapshot = snapshot as unknown as Json
+    this.data.session_total_turns = (this.data.session_total_turns ?? 0) + 1
+    this.data.updated_at = new Date().toISOString()
+
+    // Persist session state (messages already in DB)
+    await this.save()
+  }
+}