feat: sendMessage rpc returns created entry

.nvim.lua

@@ -0,0 +1,19 @@
+local ok, conform = pcall(require, "conform")
+if not ok then
+	vim.notify("conform.nvim not loaded", vim.log.levels.WARN)
+	return
+end
+
+conform.setup({
+	formatters_by_ft = {
+		javascript = { "oxfmt" },
+		javascriptreact = { "oxfmt" },
+		typescript = { "oxfmt" },
+		typescriptreact = { "oxfmt" },
+		json = { "oxfmt" },
+		jsonc = { "oxfmt" },
+	},
+})
+
+vim.lsp.enable("tsgo")
+vim.lsp.enable("oxlint")

.oxfmtrc.json

@@ -1,12 +1,12 @@
 {
-  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+	"$schema": "./node_modules/oxfmt/configuration_schema.json",
-  "useTabs": true,
+	"useTabs": true,
-  "semi": false,
+	"semi": false,
-  "trailingComma": "all",
+	"trailingComma": "all",
-  "experimentalSortImports": {
+	"experimentalSortImports": {
-    "order": "asc",
+		"order": "asc",
-    "ignoreCase": true,
+		"ignoreCase": true,
-    "newlinesBetween": true
+		"newlinesBetween": true
-  },
+	},
-  "ignorePatterns": [".claude", ".ona", "drizzle", "fixtures"]
+	"ignorePatterns": [".claude", ".ona", "drizzle", "fixtures"]
 }

apps/agent-test-cli/package.json

@@ -10,6 +10,6 @@
 	},
 	"dependencies": {
 		"@freya/agent-protocol": "workspace:*",
-		"@nym.sh/jrpc": "^0.1.0"
+		"@nym.sh/jrpc": "1.1.0"
 	}
 }

apps/agent-test-cli/src/agent-test-cli.ts

@@ -2,13 +2,13 @@ import type {
 	AgentClientApi,
 	AgentEvent,
 	AgentServerApi,
-	SendMessageResult,
 } from "@freya/agent-protocol"
 import type { JrpcChannel, JrpcMessage, JsonRpcMessage } from "@nym.sh/jrpc"
 
 import { JsonRpcClient, JsonRpcServer } from "@nym.sh/jrpc"
 
 type JsonObject = Record<string, unknown>
+type SendMessageResult = Awaited<ReturnType<AgentServerApi["sendMessage"]>>
 
 interface AuthUser {
 	id: string
@@ -71,7 +71,6 @@ class AgentWebSocketSession implements AgentClientApi {
 	private readonly client: JsonRpcClient<AgentServerApi>
 	private readonly server: JsonRpcServer<AgentClientApi>
 	private conversationId: string | undefined
-	private responseHadText = false
 
 	private constructor(channel: WebSocketJrpcChannel) {
 		this.channel = channel
@@ -105,16 +104,9 @@ class AgentWebSocketSession implements AgentClientApi {
 	}
 
 	async ask(message: string): Promise<void> {
-		this.responseHadText = false
+		const entry = await this.sendMessage(message)
-
+		this.conversationId = entry.conversationId
-		const result = await this.sendMessage(message)
+		console.log(`\nqueued> ${entry.kind} ${entry.id}`)
-		if (result.conversationId) {
-			this.conversationId = result.conversationId
-		}
-
-		if (!this.responseHadText) {
-			console.log(`\nagent> ${result.message || "(no message)"}`)
-		}
 		console.log("")
 	}
 
@@ -156,7 +148,6 @@ class AgentWebSocketSession implements AgentClientApi {
 		if (text === "") return
 
 		console.log(`\nagent> ${text}`)
-		this.responseHadText = true
 	}
 }
 

apps/freya-backend/package.json

@@ -15,8 +15,6 @@
 		"create-admin": "bun run src/scripts/create-admin.ts"
 	},
 	"dependencies": {
-		"@better-auth/core": "^1.6.20",
-		"@better-auth/expo": "^1.6.20",
 		"@earendil-works/pi-coding-agent": "^0.79.1",
 		"@freya/agent-protocol": "workspace:*",
 		"@freya/core": "workspace:*",
@@ -28,10 +26,10 @@
 		"@freya/source-tfl": "workspace:*",
 		"@freya/source-weatherkit": "workspace:*",
 		"@freya/source-web-search": "workspace:*",
-		"@nym.sh/jrpc": "^0.1.0",
+		"@nym.sh/jrpc": "1.1.0",
 		"@openrouter/sdk": "^0.9.11",
 		"arktype": "^2.1.29",
-		"better-auth": "^1.6.20",
+		"better-auth": "^1",
 		"drizzle-orm": "^0.45.1",
 		"hono": "^4",
 		"lodash.merge": "^4.6.2",

apps/freya-backend/src/admin/http.test.ts

@@ -44,7 +44,7 @@ mock.module("../sources/user-sources.ts", () => ({
 	}),
 }))
 
-mock.module("../conversations/storage.ts", () => ({
+mock.module("../conversations/db-storage.ts", () => ({
 	conversations: (_db: Database, userId: string) => ({
 		async getOrCreateConversation() {
 			return { id: `conversation-${userId}` }

apps/freya-backend/src/agent/conversation-recording-query-agent.ts

@@ -26,10 +26,13 @@ export interface ConversationStorage {
 	appendEntry(
 		conversationId: string,
 		input: AppendConversationEntryInput,
-	): Promise<ConversationStorageEntry>
+	): Promise<ConversationStorageAppendEntryResult>
 	listEntries(conversationId: string): Promise<ConversationStorageEntry[]>
 }
 
+/** Minimal fields needed immediately after appending a conversation entry. */
+export type ConversationStorageAppendEntryResult = Pick<ConversationEntryRow, "id" | "sequence">
+
 /** Minimal persisted entry shape needed by recording and replay agents. */
 export type ConversationStorageEntry = Pick<
 	ConversationEntryRow,

apps/freya-backend/src/agent/job.ts

@@ -0,0 +1,145 @@
+import type { AgentEvent } from "@freya/agent-protocol"
+
+import {
+	AssistantMessagePayload,
+	ConversationEntryKind,
+	UserMessagePayload,
+	ToolCallPayload,
+	ToolResultPayload,
+} from "@freya/core"
+import { type } from "arktype"
+
+import type { ConversationStorage } from "../conversations/storage"
+import type { Job } from "../lib/job"
+import type { JobExecutor } from "../lib/worker"
+import type { NotificationCentral } from "../notification/notification-central"
+import type { UserSessionManager } from "../session"
+
+import { ConversationResponseStateStatus } from "../db/schema"
+import { streamAgentResponse } from "./streaming"
+
+export interface AgentResponseJobPayload {
+	conversationId: string
+}
+
+interface AgentResponseWorkerConfig {
+	conversationStorage: ConversationStorage
+	userSessionManager: UserSessionManager
+	notificationCentral: NotificationCentral
+}
+
+export class AgentResponseJobExecutor implements JobExecutor<AgentResponseJobPayload> {
+	private conversationStorage: ConversationStorage
+	private userSessionManager: UserSessionManager
+	private notificationCentral: NotificationCentral
+
+	constructor({
+		conversationStorage,
+		userSessionManager,
+		notificationCentral,
+	}: AgentResponseWorkerConfig) {
+		this.conversationStorage = conversationStorage
+		this.userSessionManager = userSessionManager
+		this.notificationCentral = notificationCentral
+	}
+
+	async execute(job: Job<AgentResponseJobPayload>): Promise<void> {
+		const conversation = await this.conversationStorage.findConversation(job.payload.conversationId)
+		if (!conversation) {
+			return
+		}
+
+		const claimed = await this.conversationStorage.claimPendingConversationResponseState(
+			job.payload.conversationId,
+		)
+		if (!claimed) {
+			// conversation response state not found or already claimed
+			return
+		}
+
+		const pendingEntries = await this.conversationStorage.listPendingUserConversationEntries(
+			conversation.userId,
+			conversation.id,
+		)
+		if (pendingEntries.length === 0) {
+			await this.conversationStorage.clearConversationResponseState(job.payload.conversationId)
+			return
+		}
+
+		const message = pendingEntries.reduce((acc, entry) => {
+			const payload = UserMessagePayload(entry.payload)
+			if (payload instanceof type.errors) {
+				return acc
+			}
+			return (
+				acc + "\n" + payload.parts.reduce((msg, p) => (p.type === "text" ? msg + p.text : msg), "")
+			)
+		}, "")
+
+		const session = await this.userSessionManager.getOrCreate(conversation.userId)
+
+		try {
+			for await (const event of streamAgentResponse({
+				agent: session.agent,
+				input: { message, signal: job.signal },
+			})) {
+				if (job.signal.aborted) {
+					break
+				}
+
+				await this.recordAgentEvent(event, conversation.id)
+				await this.notificationCentral.notifyUser(conversation.userId, {
+					kind: "agent",
+					payload: event,
+				})
+			}
+
+			// if job is aborted, stop everything immediately, including clean up.
+			// the aborter is assumed responsibility on how to proceed.
+			if (!job.signal.aborted) {
+				await this.conversationStorage.clearConversationResponseState(job.payload.conversationId)
+			}
+		} catch (err) {
+			console.error("[agent job executor] error streaming agent response:", err)
+			if (!job.signal.aborted) {
+				await this.conversationStorage.markResponseStateStatus(
+					[job.payload.conversationId],
+					ConversationResponseStateStatus.Failed,
+				)
+			}
+		}
+	}
+
+	private async recordAgentEvent(event: AgentEvent, conversationId: string) {
+		switch (event.type) {
+			case "message_created":
+				await this.conversationStorage.appendEntry(conversationId, {
+					kind: ConversationEntryKind.AssistantMessage,
+					payload: {
+						role: "assistant",
+						parts: [{ type: "text", text: event.text }],
+					} satisfies AssistantMessagePayload,
+				})
+				break
+
+			case "tool_started":
+				await this.conversationStorage.appendEntry(conversationId, {
+					kind: ConversationEntryKind.ToolCall,
+					payload: {
+						toolName: event.toolName,
+					} satisfies ToolCallPayload,
+				})
+				break
+
+			case "tool_finished":
+				await this.conversationStorage.appendEntry(conversationId, {
+					kind: ConversationEntryKind.ToolResult,
+					payload: {
+						toolName: event.toolName,
+						ok: event.ok,
+					} satisfies ToolResultPayload,
+				})
+				break
+		}
+	}
+}

apps/freya-backend/src/agent/pi-query-agent.ts

@@ -166,6 +166,16 @@ export class PiQueryAgent implements QueryAgent {
 			this.handlePiEvent(event, pushRunEvent)
 		})
 
+		input.signal?.addEventListener(
+			"abort",
+			async () => {
+				await session.abort()
+				close()
+				unsubscribe()
+			},
+			{ once: true },
+		)
+
 		session
 			.prompt(input.message)
 			.then(() => {

apps/freya-backend/src/agent/query-agent.ts

@@ -2,6 +2,7 @@ export interface QueryAgentAsk {
 	message: string
 	conversationId?: string
 	userMessageEntry?: QueryAgentConversationEntryRef
+	signal?: AbortSignal
 }
 
 export type QueryAgentStreamEvent =

apps/freya-backend/src/agent/reconciler.ts

@@ -0,0 +1,70 @@
+import type { ConversationStorage } from "../conversations/storage"
+import type { AgentWorkScheduler } from "./scheduler"
+
+interface AgentResponseReconcilerConfig {
+	storage: ConversationStorage
+	interval: number
+	scheduler: AgentWorkScheduler
+	signal: AbortSignal
+}
+
+export class AgentResponseReconciler {
+	private storage: ConversationStorage
+	private interval: number
+	private scheduler: AgentWorkScheduler
+	private signal: AbortSignal
+
+	private stopLoop: ReturnType<typeof setInterval> | null = null
+
+	constructor({ storage, interval, scheduler, signal }: AgentResponseReconcilerConfig) {
+		this.storage = storage
+		this.interval = interval
+		this.scheduler = scheduler
+		this.signal = signal
+	}
+
+	start() {
+		this.signal.throwIfAborted()
+
+		this.signal.addEventListener(
+			"abort",
+			() => {
+				if (this.stopLoop !== null) {
+					clearInterval(this.stopLoop)
+					this.stopLoop = null
+				}
+			},
+			{ once: true },
+		)
+
+		this.stopLoop = setInterval(this.reconcile.bind(this), this.interval)
+	}
+
+	private async reconcile() {
+		// enqueue pending responses
+		const pendingStates = await this.storage.listPendingResponseStates()
+		const now = new Date().getTime()
+		for (const state of pendingStates) {
+			if (state.maxWaitUntil.getTime() < now) {
+				this.scheduler.enqueueAgentResponse(state.conversationId)
+			}
+		}
+
+		// re-enqueue stuck responses
+		const runningStates = await this.storage.listRunningResponseStates()
+		const stuckIds: string[] = []
+		for (const state of runningStates) {
+			if (state.runningSince && Math.max(now - state.runningSince.getTime(), 0) > 5 * 1000 * 60) {
+				// if the response is running for more than 5 minutes
+				// we assume that its stuck and enqueue it for retry
+				stuckIds.push(state.conversationId)
+			}
+		}
+		if (stuckIds.length > 0) {
+			await this.storage.markResponseStateStatus(stuckIds, "pending")
+			for (const id of stuckIds) {
+				this.scheduler.enqueueAgentResponse(id)
+			}
+		}
+	}
+}

apps/freya-backend/src/agent/scheduler.ts

@@ -0,0 +1,136 @@
+import type { UserEvent } from "@freya/agent-protocol"
+
+import type { ConversationStorage } from "../conversations/storage"
+import type { Job, JobRegistry } from "../lib/job"
+import type { AgentResponseJobPayload } from "./job"
+
+import { ConversationNotFoundError } from "../conversations/errors"
+import { ConversationResponseStateStatus } from "../db/schema"
+
+interface AgentMessageSchedulerConfig {
+	storage: ConversationStorage
+	maxWaitTime: number
+
+	/**
+	 * How long to wait before responding to the user.
+	 */
+	waitTIme: number
+
+	jobRegistry: JobRegistry<AgentResponseJobPayload>
+}
+
+/**
+ * Schedules and manages the flow of messages between the user and the query agent for a specific conversation.
+ */
+export class AgentWorkScheduler {
+	private conversationStorage: ConversationStorage
+	private jobRegistry: JobRegistry<AgentResponseJobPayload>
+
+	private timing: {
+		maxWaitTime: number
+		waitTime: number
+	}
+
+	private timers = new Map<string, ReturnType<typeof setTimeout>>()
+	private runningJobs = new Map<string, Job<AgentResponseJobPayload>>()
+
+	constructor(config: AgentMessageSchedulerConfig) {
+		this.conversationStorage = config.storage
+		this.jobRegistry = config.jobRegistry
+		this.timing = {
+			maxWaitTime: config.maxWaitTime,
+			waitTime: config.waitTIme,
+		}
+
+		this.jobRegistry.addEventListener("settled", this.eraseJob.bind(this))
+		this.jobRegistry.addEventListener("cancelled", this.eraseJob.bind(this))
+	}
+
+	async scheduleAgentResponse(conversationId: string) {
+		const existing = this.timers.get(conversationId)
+		if (existing) {
+			clearTimeout(existing)
+		}
+
+		this.cancelCurrentJob(conversationId)
+
+		this.timers.set(
+			conversationId,
+			setTimeout(() => {
+				this.enqueueAgentResponse(conversationId)
+			}, this.timing.waitTime),
+		)
+	}
+
+	async receiveUserEvent(conversationId: string, event: UserEvent) {
+		if (event.type === "typing") {
+			await this.delayAgentResponse(conversationId)
+		}
+	}
+
+	enqueueAgentResponse(conversationId: string): void {
+		const existing = this.timers.get(conversationId)
+		if (existing) {
+			clearTimeout(existing)
+			this.timers.delete(conversationId)
+		}
+
+		this.cancelCurrentJob(conversationId)
+
+		const job = this.jobRegistry.addJob({
+			payload: { conversationId },
+		})
+		this.runningJobs.set(conversationId, job)
+	}
+
+	private async delayAgentResponse(conversationId: string) {
+		this.cancelCurrentJob(conversationId)
+
+		try {
+			const ok = await this.conversationStorage.transaction(async (storage) => {
+				const state = await storage.findConversationResponseState(conversationId)
+				if (state && state.status !== ConversationResponseStateStatus.Failed) {
+					await storage.updateConversationResponseState(conversationId, {
+						status: ConversationResponseStateStatus.Pending,
+						// the agent response was cancelled, so its no longer running
+						// clear runningSince timestamp
+						runningSince: null,
+					})
+					return true
+				}
+				return false
+			})
+			if (ok) {
+				await this.scheduleAgentResponse(conversationId)
+			}
+		} catch (error) {
+			if (error instanceof ConversationNotFoundError) {
+				// the user is typing but there isn't a scheduled agent response yet
+				// which means the user is typing their first message after the agent has previously responded
+				// swallow the error
+			} else {
+				console.error("[agent response scheduler] error delaying agent response", error)
+			}
+			return
+		}
+	}
+
+	/**
+	 * cancels the current job for agent response for the given conversation id
+	 * no-op if there is no active job for the conversation.
+	 */
+	private cancelCurrentJob(conversationId: string): void {
+		const job = this.runningJobs.get(conversationId)
+		if (!job) return
+
+		// If an active response is working on stale context, abort it so the next
+		// job can answer using the latest pending user messages.
+		this.jobRegistry.cancelJob(job)
+	}
+
+	private eraseJob(job: Job<AgentResponseJobPayload>) {
+		if (this.runningJobs.get(job.payload.conversationId) === job) {
+			this.runningJobs.delete(job.payload.conversationId)
+		}
+	}
+}

apps/freya-backend/src/agent/service.ts

@@ -0,0 +1,95 @@
+import type { UserEvent } from "@freya/agent-protocol"
+
+import { ConversationEntry, ConversationEntryKind, UserMessagePayload } from "@freya/core"
+
+import type { ConversationStorage } from "../conversations/storage"
+import type { NotificationCentral } from "../notification/notification-central"
+import type { UserSessionManager } from "../session"
+
+import { JobRegistry } from "../lib/job"
+import { Worker } from "../lib/worker"
+import { AgentResponseJobExecutor, type AgentResponseJobPayload } from "./job"
+import { AgentResponseReconciler } from "./reconciler"
+import { AgentWorkScheduler } from "./scheduler"
+
+const AgentResponseTiming = {
+	waitTime: 5 * 1000,
+	maxWaitTime: 5 * 1000 * 60,
+} as const
+
+interface AgentServiceConfig {
+	storage: ConversationStorage
+	userSessionManager: UserSessionManager
+	notificationCentral: NotificationCentral
+	signal: AbortSignal
+}
+
+export class AgentService {
+	private readonly storage: ConversationStorage
+	private readonly scheduler: AgentWorkScheduler
+	private readonly reconciler: AgentResponseReconciler
+	private readonly worker: Worker<AgentResponseJobPayload>
+
+	private readonly jobRegistry = new JobRegistry<AgentResponseJobPayload>()
+
+	constructor({ storage, userSessionManager, notificationCentral, signal }: AgentServiceConfig) {
+		this.storage = storage
+		this.scheduler = new AgentWorkScheduler({
+			storage,
+			jobRegistry: this.jobRegistry,
+			waitTIme: AgentResponseTiming.waitTime,
+			maxWaitTime: AgentResponseTiming.maxWaitTime,
+		})
+		this.reconciler = new AgentResponseReconciler({
+			signal,
+			storage: this.storage,
+			interval: 60 * 1000,
+			scheduler: this.scheduler,
+		})
+		this.worker = new Worker<AgentResponseJobPayload>({
+			signal,
+			concurrency: 10,
+			registry: this.jobRegistry,
+			runner: new AgentResponseJobExecutor({
+				conversationStorage: storage,
+				notificationCentral,
+				userSessionManager,
+			}),
+		})
+	}
+
+	start() {
+		this.worker.start()
+		this.reconciler.start()
+	}
+
+	async scheduleAgentResponse(conversationId: string, message: string): Promise<ConversationEntry> {
+		const createdEntry = await this.storage.transaction(async (storage) => {
+			const now = new Date()
+
+			const entry = await storage.appendEntry(conversationId, {
+				kind: ConversationEntryKind.UserMessage,
+				payload: {
+					role: "user",
+					parts: [{ type: "text", text: message }],
+				} satisfies UserMessagePayload,
+			})
+
+			await storage.upsertConversationResponseState(conversationId, {
+				maxWaitUntil: new Date(now.getTime() + AgentResponseTiming.maxWaitTime),
+				pendingSinceEntryId: entry.id,
+				status: "pending",
+			})
+
+			return entry
+		})
+
+		await this.scheduler.scheduleAgentResponse(conversationId)
+
+		return createdEntry
+	}
+
+	async handleUserEvent(conversationId: string, event: UserEvent) {
+		await this.scheduler.receiveUserEvent(conversationId, event)
+	}
+}

apps/freya-backend/src/agent/streaming.test.ts

@@ -9,7 +9,6 @@ import type {
 	QueryAgentEventListener,
 	QueryAgentStreamEvent,
 } from "./query-agent.ts"
-import type { AgentResponseStreamItem } from "./streaming.ts"
 
 import { streamAgentResponse } from "./streaming.ts"
 
@@ -47,17 +46,13 @@ describe("streamAgentResponse", () => {
 			{ type: "done" },
 		])
 
-		const { events, result } = await collectStreamAgentResponse(
+		const events = await collectStreamAgentResponse(
 			streamAgentResponse({
 				agent,
 				input: { message: "hello" },
 			}),
 		)
 
-		expect(result).toEqual({
-			conversationId: "conversation-1",
-			message: "First message\nSecond message\nThird message",
-		})
 		expect(events).toEqual([
 			{ type: "conversation_started", conversationId: "conversation-1" },
 			{ type: "message_created", text: "First message" },
@@ -74,17 +69,13 @@ describe("streamAgentResponse", () => {
 			{ type: "done" },
 		])
 
-		const { events, result } = await collectStreamAgentResponse(
+		const events = await collectStreamAgentResponse(
 			streamAgentResponse({
 				agent,
 				input: { message: "hello" },
 			}),
 		)
 
-		expect(result).toEqual({
-			conversationId: "conversation-1",
-			message: "  const value = 1  \n\n  return value",
-		})
 		expect(events).toEqual([
 			{ type: "conversation_started", conversationId: "conversation-1" },
 			{ type: "message_created", text: "  const value = 1  " },
@@ -122,28 +113,12 @@ describe("streamAgentResponse", () => {
 })
 
 async function collectStreamAgentResponse(
-	stream: AsyncIterable<AgentResponseStreamItem>,
+	stream: AsyncIterable<AgentEvent>,
 	events: AgentEvent[] = [],
-): Promise<{
+): Promise<AgentEvent[]> {
-	events: AgentEvent[]
+	for await (const event of stream) {
-	result: { message: string; conversationId: string }
+		events.push(event)
-}> {
-	let result: { message: string; conversationId: string } | null = null
-
-	for await (const item of stream) {
-		switch (item.type) {
-			case "event":
-				events.push(item.event)
-				break
-			case "result":
-				result = item.result
-				break
-		}
 	}
 
-	if (!result) {
+	return events
-		throw new Error("Expected stream result")
-	}
-
-	return { events, result }
 }

apps/freya-backend/src/agent/streaming.ts

@@ -1,10 +1,8 @@
-import type { AgentEvent, SendMessageResult } from "@freya/agent-protocol"
+import type { AgentEvent } from "@freya/agent-protocol"
 
 import type { QueryAgent, QueryAgentAsk } from "./query-agent.ts"
 
-export type AgentResponseStreamItem =
+export type AgentResponseStreamItem = { type: "event"; event: AgentEvent }
-	| { type: "event"; event: AgentEvent }
-	| { type: "result"; result: SendMessageResult }
 
 export async function* streamAgentResponse({
 	agent,
@@ -12,18 +10,18 @@ export async function* streamAgentResponse({
 }: {
 	agent: QueryAgent
 	input: QueryAgentAsk
-}): AsyncGenerator<AgentResponseStreamItem, void, void> {
+}): AsyncGenerator<AgentEvent, void, void> {
 	let message = ""
 	let conversationId: string | null = null
 	const splitter = new AgentMessageSplitter()
 
-	function messageEvent(text: string): AgentResponseStreamItem | null {
+	function messageEvent(text: string): AgentEvent | null {
 		if (text.trim() === "") return null
 
-		return { type: "event", event: { type: "message_created", text } }
+		return { type: "message_created", text }
 	}
 
-	function flushPendingMessage(): AgentResponseStreamItem | null {
+	function flushPendingMessage(): AgentEvent | null {
 		const text = splitter.flush()
 		if (text === null) return null
 
@@ -31,10 +29,14 @@ export async function* streamAgentResponse({
 	}
 
 	for await (const event of agent.ask(input)) {
+		if (input.signal?.aborted) {
+			break
+		}
+
 		switch (event.type) {
 			case "conversation":
 				conversationId = event.conversationId
-				yield { type: "event", event: { type: "conversation_started", conversationId } }
+				yield { type: "conversation_started", conversationId }
 				break
 
 			case "text_delta":
@@ -50,7 +52,7 @@ export async function* streamAgentResponse({
 					const item = flushPendingMessage()
 					if (item) yield item
 				}
-				yield { type: "event", event: { type: "tool_started", toolName: event.toolName } }
+				yield { type: "tool_started", toolName: event.toolName }
 				break
 
 			case "tool_end":
@@ -59,12 +61,9 @@ export async function* streamAgentResponse({
 					if (item) yield item
 				}
 				yield {
-					type: "event",
+					type: "tool_finished",
-					event: {
+					toolName: event.toolName,
-						type: "tool_finished",
+					ok: event.ok,
-						toolName: event.toolName,
-						ok: event.ok,
-					},
 				}
 				break
 
@@ -73,7 +72,7 @@ export async function* streamAgentResponse({
 					const item = flushPendingMessage()
 					if (item) yield item
 				}
-				yield { type: "event", event: { type: "message_failed", error: event.message } }
+				yield { type: "message_failed", error: event.message }
 				throw new Error(event.message)
 
 			case "done":
@@ -81,26 +80,15 @@ export async function* streamAgentResponse({
 					const item = flushPendingMessage()
 					if (item) yield item
 				}
-				const result = createResult(message, conversationId)
+				yield { type: "message_finished" }
-				yield { type: "event", event: { type: "message_finished" } }
-				yield { type: "result", result }
 				return
 		}
 	}
 
 	const item = flushPendingMessage()
 	if (item) yield item
-	const result = createResult(message, conversationId)
-	yield { type: "event", event: { type: "message_finished" } }
-	yield { type: "result", result }
-}
 
-function createResult(message: string, conversationId: string | null): SendMessageResult {
+	yield { type: "message_finished" }
-	if (!conversationId) {
-		throw new Error("Agent response stream ended without a conversation id")
-	}
-
-	return { message, conversationId }
 }
 
 class AgentMessageSplitter {

apps/freya-backend/src/agent/ws.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test"
 import { Hono } from "hono"
 
-import type { UserSessionManager } from "../session/index.ts"
+import type { ConversationStorage } from "../conversations/storage.ts"
+import type { NotificationCentral } from "../notification/notification-central.ts"
 
+import type { AgentService } from "./service.ts"
 import { registerAgentWebSocketHandlers } from "./ws.ts"
 
 describe("agent websocket handler", () => {
@@ -11,7 +13,9 @@ describe("agent websocket handler", () => {
 		const app = new Hono()
 
 		registerAgentWebSocketHandlers(app, {
-			sessionManager: {} as UserSessionManager,
+			agentService: {} as AgentService,
+			storage: {} as ConversationStorage,
+			notificationCentral: {} as NotificationCentral,
 			corsMiddleware: async (c, next) => {
 				const origin = c.req.header("origin")
 				if (origin && origin !== "https://app.freya.test") {
@@ -44,7 +48,9 @@ describe("agent websocket handler", () => {
 		const app = new Hono()
 
 		registerAgentWebSocketHandlers(app, {
-			sessionManager: {} as UserSessionManager,
+			agentService: {} as AgentService,
+			storage: {} as ConversationStorage,
+			notificationCentral: {} as NotificationCentral,
 			corsMiddleware: async (_c, next) => {
 				await next()
 			},

apps/freya-backend/src/agent/ws.ts

@@ -1,53 +1,59 @@
-import type { AgentClientApi, AgentServerApi, SendMessageResult } from "@freya/agent-protocol"
+import type { AgentClientApi, AgentServerApi, UserEvent } from "@freya/agent-protocol"
+import type { ConversationEntry } from "@freya/core"
 import type { JrpcChannel, JrpcMessage, JsonRpcMessage } from "@nym.sh/jrpc"
 import type { Hono, MiddlewareHandler } from "hono"
 import type { WSContext } from "hono/ws"
 
-import { JsonRpcClient, JsonRpcServer } from "@nym.sh/jrpc"
+import { JsonRpcClient, JsonRpcServer, deserializeJrpcMessage } from "@nym.sh/jrpc"
-import { type } from "arktype"
 import { upgradeWebSocket, websocket } from "hono/bun"
 
 import type { AuthSessionMiddleware } from "../auth/session-middleware.ts"
-import type { UserSessionManager } from "../session/index.ts"
+import type { ConversationStorage } from "../conversations/storage.ts"
-
+import type {
-import { streamAgentResponse } from "./streaming.ts"
+	NotificationCentral,
+	NotificationPayload,
+} from "../notification/notification-central.ts"
+import type { AgentService } from "./service.ts"
 
 interface AgentWebSocketHandlerDeps {
-	sessionManager: UserSessionManager
+	agentService: AgentService
+	storage: ConversationStorage
+	notificationCentral: NotificationCentral
 	authSessionMiddleware: AuthSessionMiddleware
 	corsMiddleware: MiddlewareHandler
 }
 
-interface ValidSendMessageInput {
-	message: string
-}
-
 export const agentWebSocket = websocket
 
-const SendMessageInputBody = type({
-	"+": "reject",
-	message: "string",
-})
-
 export function registerAgentWebSocketHandlers(
 	app: Hono,
-	{ sessionManager, authSessionMiddleware, corsMiddleware }: AgentWebSocketHandlerDeps,
+	{
+		agentService,
+		storage,
+		notificationCentral,
+		authSessionMiddleware,
+		corsMiddleware,
+	}: AgentWebSocketHandlerDeps,
 ): void {
 	app.get(
 		"/api/agent/ws",
 		corsMiddleware,
 		authSessionMiddleware,
-		upgradeWebSocket((c) => {
+		upgradeWebSocket(async (c) => {
 			const user = c.get("user")
 			if (!user) {
 				throw new Error("Authenticated WebSocket user missing")
 			}
 
+			const conversation = await storage.getOrCreateConversation(user.id)
+
 			const channel = new HonoWebSocketJrpcChannel()
 			const connection = new AgentRpcConnection({
 				channel,
-				sessionManager,
+				notificationCentral,
+				agentService,
 				userId: user.id,
+				conversationId: conversation.id,
 			})
 
 			return {
@@ -64,6 +70,7 @@ export function registerAgentWebSocketHandlers(
 				},
 
 				onClose() {
+					connection.close()
 					channel.close()
 				},
 			}
@@ -74,54 +81,51 @@ export function registerAgentWebSocketHandlers(
 class AgentRpcConnection implements AgentServerApi {
 	private readonly client: JsonRpcClient<AgentClientApi>
 	private readonly server: JsonRpcServer<AgentServerApi>
-	private activeMessage: Promise<SendMessageResult> | null = null
+	private readonly agentService: AgentService
-	private readonly sessionManager: UserSessionManager
+	private readonly notificationCentral: NotificationCentral
 	private readonly userId: string
+	private readonly conversationId: string
+
+	private cleanup: (() => void) | null = null
 
 	constructor({
+		agentService,
+		notificationCentral,
 		channel,
-		sessionManager,
 		userId,
+		conversationId,
 	}: {
+		agentService: AgentService
+		notificationCentral: NotificationCentral
 		channel: JrpcChannel
-		sessionManager: UserSessionManager
 		userId: string
+		conversationId: string
 	}) {
-		this.sessionManager = sessionManager
-		this.userId = userId
 		this.client = new JsonRpcClient<AgentClientApi>(channel)
+		this.agentService = agentService
+		this.notificationCentral = notificationCentral
+		this.userId = userId
+		this.conversationId = conversationId
 		this.server = new JsonRpcServer<AgentServerApi>(
 			{
 				sendMessage: this.sendMessage.bind(this),
+				notify: this.notify.bind(this),
 				ping: this.ping.bind(this),
 			},
 			channel,
 		)
 	}
 
-	start(): Promise<void> {
+	notify(event: UserEvent): void {
-		return this.server.start()
+		this.agentService.handleUserEvent(this.conversationId, event)
 	}
 
-	async sendMessage(message: string): Promise<SendMessageResult> {
+	async sendMessage(message: string): Promise<ConversationEntry> {
-		const parsed = SendMessageInputBody({ message })
-		if (parsed instanceof type.errors) {
-			throw new Error(parsed.summary)
-		}
-
-		if (this.activeMessage) {
-			throw new Error("A message is already running")
-		}
-
-		const run = this.runMessage(parsed)
-		this.activeMessage = run
-
 		try {
-			return await run
+			return await this.agentService.scheduleAgentResponse(this.conversationId, message)
-		} finally {
+		} catch (error) {
-			if (this.activeMessage === run) {
+			console.error("[agent rpc connection] error when scheduling agent response", error)
-				this.activeMessage = null
+			throw error
-			}
 		}
 	}
 
@@ -129,26 +133,22 @@ class AgentRpcConnection implements AgentServerApi {
 		return "pong"
 	}
 
-	private async runMessage(input: ValidSendMessageInput): Promise<SendMessageResult> {
+	async start() {
-		const session = await this.sessionManager.getOrCreate(this.userId)
+		this.cleanup = this.notificationCentral.registerListenerForUser(
-		let result: SendMessageResult | null = null
+			this.userId,
+			this.onNotificationReceived.bind(this),
+		)
+		await this.server.start()
+	}
 
-		for await (const item of streamAgentResponse({ agent: session.agent, input })) {
+	close() {
-			switch (item.type) {
+		this.cleanup?.()
-				case "event":
+	}
-					await this.client.call("notify", item.event)
+
-					break
+	private async onNotificationReceived(notification: NotificationPayload) {
-				case "result":
+		if (notification.kind === "agent") {
-					result = item.result
+			await this.client.call("notify", notification.payload)
-					break
-			}
 		}
-
-		if (!result) {
-			throw new Error("Agent response stream ended without a result")
-		}
-
-		return result
 	}
 }
 
@@ -171,7 +171,11 @@ class HonoWebSocketJrpcChannel implements JrpcChannel {
 	}
 
 	receive(message: unknown): void {
-		const parsed = parseJrpcMessage(message)
+		if (typeof message !== "string") {
+			return
+		}
+
+		const parsed = deserializeJrpcMessage(message)
 		if (!parsed) {
 			this.ws?.close(1003, "Invalid JSON-RPC message")
 			return
@@ -236,52 +240,6 @@ class HonoWebSocketJrpcChannel implements JrpcChannel {
 	}
 }
 
-function parseJrpcMessage(message: unknown): JrpcMessage | null {
-	const text = webSocketMessageText(message)
-	if (text === null) return null
-
-	try {
-		const value: unknown = JSON.parse(text)
-		return isJrpcMessage(value) ? value : null
-	} catch {
-		return null
-	}
-}
-
-function webSocketMessageText(message: unknown): string | null {
-	if (typeof message === "string") return message
-	if (message instanceof ArrayBuffer) return Buffer.from(message).toString("utf8")
-	if (ArrayBuffer.isView(message)) {
-		return Buffer.from(message.buffer, message.byteOffset, message.byteLength).toString("utf8")
-	}
-
-	return null
-}
-
-function isJrpcMessage(value: unknown): value is JrpcMessage {
-	if (typeof value !== "object" || value === null) return false
-	if (!("jsonrpc" in value) || value.jsonrpc !== "2.0") return false
-
-	if ("method" in value) {
-		return "id" in value && typeof value.id === "number" && typeof value.method === "string"
-	}
-
-	if ("result" in value) {
-		return "id" in value && typeof value.id === "number"
-	}
-
-	if ("error" in value) {
-		return (
-			"id" in value &&
-			typeof value.id === "number" &&
-			typeof value.error === "object" &&
-			value.error !== null
-		)
-	}
-
-	return false
-}
-
 function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error)
 }

apps/freya-backend/src/auth/index.ts

@@ -1,4 +1,3 @@
-import { expo } from "@better-auth/expo"
 import { betterAuth } from "better-auth"
 import { drizzleAdapter } from "better-auth/adapters/drizzle"
 import { admin } from "better-auth/plugins"
@@ -33,7 +32,7 @@ export function createAuth(db: Database) {
 				},
 			},
 		},
-		plugins: [admin(), expo()],
+		plugins: [admin()],
 	})
 }
 

apps/freya-backend/src/conversations/db-storage.ts

@@ -0,0 +1,691 @@
+import {
+	AssistantMessagePayload,
+	AttachmentPayload,
+	ConversationEntryKind,
+	ConversationEntryMetadata,
+	ConversationEntryVisibility,
+	ContextSummaryPayload,
+	GenericObjectPayload,
+	UserMessagePayload,
+	type ConversationEntry,
+	type ConversationEntryPayload,
+} from "@freya/core"
+import { type } from "arktype"
+import { and, asc, desc, eq, gte, inArray } from "drizzle-orm"
+import { alias } from "drizzle-orm/pg-core"
+
+import type { Database } from "../db/index.ts"
+import type {
+	AppendAttachmentEntryInput,
+	AppendAttachmentEntryResult,
+	AppendConversationEntryInput,
+	ConversationEntryRow,
+	ConversationResponseStateRow,
+	ConversationRow,
+	ConversationStorage,
+	CreateFileInput,
+	FileRow,
+	ListConversationEntriesParams,
+	UpdateConversationResponseStateInput,
+	UpsertConversationResponseStateInput,
+} from "./storage.ts"
+
+import {
+	conversationEntries,
+	ConversationResponseStateStatus,
+	conversationResponseState as conversationResponseStateTable,
+	conversations as conversationsTable,
+	files,
+	user,
+} from "../db/schema.ts"
+import { ConversationNotFoundError } from "./errors.ts"
+import { conversationEntryFromRow } from "./serialization.ts"
+
+const conversationEntryKind = type.enumerated(...Object.values(ConversationEntryKind))
+const conversationEntryVisibility = type.enumerated(...Object.values(ConversationEntryVisibility))
+const pendingSinceEntry = alias(conversationEntries, "pending_since_entry")
+
+export class DrizzleConversationStorage implements ConversationStorage {
+	private readonly db: Database
+	private readonly inTransaction: boolean
+
+	constructor(db: Database, inTransaction = false) {
+		this.db = db
+		this.inTransaction = inTransaction
+	}
+
+	async transaction<T>(tx: (storage: ConversationStorage) => T | Promise<T>): Promise<T> {
+		if (this.inTransaction) return tx(this)
+
+		return this.db.transaction(async (transactionDb) =>
+			tx(new DrizzleConversationStorage(transactionDb, true)),
+		)
+	}
+
+	async createConversation(userId: string): Promise<ConversationRow> {
+		return insertConversation(this.db, userId)
+	}
+
+	async listUserConversations(userId: string): Promise<ConversationRow[]> {
+		return this.db
+			.select()
+			.from(conversationsTable)
+			.where(eq(conversationsTable.userId, userId))
+			.orderBy(desc(conversationsTable.updatedAt), desc(conversationsTable.createdAt))
+	}
+
+	async findConversation(conversationId: string): Promise<ConversationRow | null> {
+		return findConversation(this.db, conversationId)
+	}
+
+	async getOrCreateConversation(userId: string): Promise<ConversationRow> {
+		return this.write(async (db) => {
+			await requireUserForUpdate(db, userId)
+			const existing = await latestConversation(db, userId)
+			if (existing) return existing
+
+			return insertConversation(db, userId)
+		})
+	}
+
+	async createFile(userId: string, input: CreateFileInput): Promise<FileRow> {
+		return insertFile(this.db, userId, input)
+	}
+
+	async appendEntry(
+		conversationId: string,
+		input: AppendConversationEntryInput,
+	): Promise<ConversationEntry> {
+		const row = await this.write((db) => appendEntryToConversation(db, null, conversationId, input))
+		return conversationEntryFromRow(row)
+	}
+
+	async appendAttachmentEntry(
+		conversationId: string,
+		input: AppendAttachmentEntryInput,
+	): Promise<AppendAttachmentEntryResult> {
+		return this.write((db) => appendAttachmentEntryToConversation(db, null, conversationId, input))
+	}
+
+	async nextSequence(conversationId: string): Promise<number> {
+		return nextSequence(this.db, conversationId)
+	}
+
+	async listUserConversationEntries(
+		userId: string,
+		conversationId: string,
+		params: ListConversationEntriesParams = {},
+	): Promise<ConversationEntryRow[]> {
+		if (!(await findUserConversation(this.db, userId, conversationId))) {
+			throw new ConversationNotFoundError(conversationId, userId)
+		}
+
+		if (params.visibility) {
+			return this.db
+				.select()
+				.from(conversationEntries)
+				.where(
+					and(
+						eq(conversationEntries.conversationId, conversationId),
+						eq(conversationEntries.visibility, params.visibility),
+					),
+				)
+				.orderBy(asc(conversationEntries.sequence))
+		}
+
+		return this.db
+			.select()
+			.from(conversationEntries)
+			.where(eq(conversationEntries.conversationId, conversationId))
+			.orderBy(asc(conversationEntries.sequence))
+	}
+
+	async listPendingUserConversationEntries(
+		userId: string,
+		conversationId: string,
+	): Promise<ConversationEntryRow[]> {
+		const entries = await this.db
+			.select({ entry: conversationEntries })
+			.from(conversationResponseStateTable)
+			.innerJoin(
+				conversationsTable,
+				and(
+					eq(conversationsTable.id, conversationResponseStateTable.conversationId),
+					eq(conversationsTable.userId, userId),
+				),
+			)
+			.innerJoin(
+				pendingSinceEntry,
+				and(
+					eq(pendingSinceEntry.id, conversationResponseStateTable.pendingSinceEntryId),
+					eq(pendingSinceEntry.conversationId, conversationResponseStateTable.conversationId),
+				),
+			)
+			.innerJoin(
+				conversationEntries,
+				and(
+					eq(conversationEntries.conversationId, conversationResponseStateTable.conversationId),
+					eq(conversationEntries.kind, ConversationEntryKind.UserMessage),
+					gte(conversationEntries.sequence, pendingSinceEntry.sequence),
+				),
+			)
+			.where(
+				and(
+					eq(conversationResponseStateTable.conversationId, conversationId),
+					eq(conversationEntries.conversationId, conversationId),
+				),
+			)
+			.orderBy(asc(conversationEntries.sequence))
+
+		if (entries.length > 0) return entries.map(({ entry }) => entry)
+		if (await findUserConversation(this.db, userId, conversationId)) return []
+
+		throw new ConversationNotFoundError(conversationId, userId)
+	}
+
+	async findConversationResponseState(
+		conversationId: string,
+	): Promise<ConversationResponseStateRow | null> {
+		const rows = await this.db
+			.select()
+			.from(conversationResponseStateTable)
+			.where(eq(conversationResponseStateTable.conversationId, conversationId))
+			.limit(1)
+
+		return rows[0] ?? null
+	}
+
+	async listPendingResponseStates(): Promise<ConversationResponseStateRow[]> {
+		const rows = await this.db
+			.select()
+			.from(conversationResponseStateTable)
+			.where(eq(conversationResponseStateTable.status, ConversationResponseStateStatus.Pending))
+
+		return rows
+	}
+
+	async listRunningResponseStates(): Promise<ConversationResponseStateRow[]> {
+		const rows = await this.db
+			.select()
+			.from(conversationResponseStateTable)
+			.where(eq(conversationResponseStateTable.status, ConversationResponseStateStatus.Running))
+
+		return rows
+	}
+
+	async upsertConversationResponseState(
+		conversationId: string,
+		input: UpsertConversationResponseStateInput,
+	): Promise<ConversationResponseStateRow> {
+		const now = new Date()
+
+		return this.write(async (db) => {
+			if (!(await findConversationByIdForUpdate(db, conversationId))) {
+				throw new ConversationNotFoundError(conversationId, "")
+			}
+
+			const rows = await db
+				.insert(conversationResponseStateTable)
+				.values({
+					conversationId,
+					status: input.status ?? ConversationResponseStateStatus.Pending,
+					pendingSinceEntryId: input.pendingSinceEntryId,
+					maxWaitUntil: input.maxWaitUntil,
+					runningSince: input.runningSince ?? null,
+					updatedAt: now,
+				})
+				.onConflictDoUpdate({
+					target: conversationResponseStateTable.conversationId,
+					set: {
+						status: input.status ?? ConversationResponseStateStatus.Pending,
+						maxWaitUntil: input.maxWaitUntil,
+						runningSince: input.runningSince ?? null,
+						updatedAt: now,
+					},
+				})
+				.returning()
+
+			return requireRow(rows)
+		})
+	}
+
+	async updateConversationResponseState(
+		conversationId: string,
+		input: UpdateConversationResponseStateInput,
+	): Promise<ConversationResponseStateRow | null> {
+		return this.write(async (db) => {
+			if (!(await findConversationByIdForUpdate(db, conversationId))) {
+				throw new ConversationNotFoundError(conversationId, "")
+			}
+
+			const rows = await db
+				.update(conversationResponseStateTable)
+				.set({
+					status: input.status,
+					pendingSinceEntryId: input.pendingSinceEntryId,
+					maxWaitUntil: input.maxWaitUntil,
+					runningSince: input.runningSince,
+					updatedAt: new Date(),
+				})
+				.where(eq(conversationResponseStateTable.conversationId, conversationId))
+				.returning()
+
+			return rows[0] ?? null
+		})
+	}
+
+	async markResponseStateStatus(
+		conversationIds: string[],
+		status: ConversationResponseStateStatus,
+	): Promise<ConversationResponseStateRow[]> {
+		return this.write(async (db) => {
+			const now = new Date()
+
+			let runningSince: Date | null
+			switch (status) {
+				case "pending":
+				case "failed":
+					runningSince = null
+					break
+				case "running":
+					runningSince = now
+					break
+			}
+
+			const rows = await db
+				.update(conversationResponseStateTable)
+				.set({
+					status,
+					runningSince,
+					updatedAt: now,
+				})
+				.where(inArray(conversationResponseStateTable.conversationId, conversationIds))
+				.returning()
+
+			return rows
+		})
+	}
+
+	async claimPendingConversationResponseState(
+		conversationId: string,
+	): Promise<ConversationResponseStateRow | null> {
+		return this.write(async (db) => {
+			const now = new Date()
+			const rows = await db
+				.update(conversationResponseStateTable)
+				.set({
+					status: "running",
+					runningSince: now,
+					updatedAt: now,
+				})
+				.where(
+					and(
+						eq(conversationResponseStateTable.conversationId, conversationId),
+						eq(conversationResponseStateTable.status, "pending"),
+					),
+				)
+				.returning()
+
+			return rows[0] ?? null
+		})
+	}
+
+	async clearConversationResponseState(conversationId: string): Promise<void> {
+		await this.write(async (db) => {
+			if (!(await findConversationByIdForUpdate(db, conversationId))) {
+				throw new ConversationNotFoundError(conversationId, "")
+			}
+
+			await db
+				.delete(conversationResponseStateTable)
+				.where(eq(conversationResponseStateTable.conversationId, conversationId))
+		})
+	}
+
+	private async write<T>(fn: (db: Database) => Promise<T>): Promise<T> {
+		if (this.inTransaction) return fn(this.db)
+
+		return this.db.transaction(fn)
+	}
+}
+
+export function createConversationStorage(db: Database): ConversationStorage {
+	return new DrizzleConversationStorage(db)
+}
+
+export function conversations(db: Database, userId: string) {
+	const storage = createConversationStorage(db)
+
+	return {
+		createConversation(): Promise<ConversationRow> {
+			return storage.createConversation(userId)
+		},
+
+		listConversations(): Promise<ConversationRow[]> {
+			return storage.listUserConversations(userId)
+		},
+
+		getConversation(conversationId: string): Promise<ConversationRow | null> {
+			return findUserConversation(db, userId, conversationId)
+		},
+
+		getOrCreateConversation(): Promise<ConversationRow> {
+			return storage.getOrCreateConversation(userId)
+		},
+
+		createFile(input: CreateFileInput): Promise<FileRow> {
+			return storage.createFile(userId, input)
+		},
+
+		appendEntry(
+			conversationId: string,
+			input: AppendConversationEntryInput,
+		): Promise<ConversationEntry> {
+			return db.transaction((tx) =>
+				appendEntryToConversation(tx, userId, conversationId, input).then(conversationEntryFromRow),
+			)
+		},
+
+		appendAttachmentEntry(
+			conversationId: string,
+			input: AppendAttachmentEntryInput,
+		): Promise<AppendAttachmentEntryResult> {
+			return db.transaction((tx) =>
+				appendAttachmentEntryToConversation(tx, userId, conversationId, input),
+			)
+		},
+
+		listEntries(
+			conversationId: string,
+			params: ListConversationEntriesParams = {},
+		): Promise<ConversationEntryRow[]> {
+			return storage.listUserConversationEntries(userId, conversationId, params)
+		},
+	}
+}
+
+export function conversationResponse(db: Database, _userId: string, conversationId: string) {
+	const storage = createConversationStorage(db)
+
+	return {
+		get(): Promise<ConversationResponseStateRow | null> {
+			return storage.findConversationResponseState(conversationId)
+		},
+
+		upsert(input: UpsertConversationResponseStateInput): Promise<ConversationResponseStateRow> {
+			return storage.upsertConversationResponseState(conversationId, input)
+		},
+
+		update(
+			input: UpdateConversationResponseStateInput,
+		): Promise<ConversationResponseStateRow | null> {
+			return storage.updateConversationResponseState(conversationId, input)
+		},
+
+		clear(): Promise<void> {
+			return storage.clearConversationResponseState(conversationId)
+		},
+	}
+}
+
+function payloadForKind(
+	kind: ConversationEntryKind,
+	payload: AppendConversationEntryInput["payload"],
+): ConversationEntryPayload {
+	switch (kind) {
+		case ConversationEntryKind.UserMessage:
+			return UserMessagePayload.assert(payload)
+		case ConversationEntryKind.AssistantMessage:
+			return AssistantMessagePayload.assert(payload)
+		case ConversationEntryKind.Attachment:
+			return AttachmentPayload.assert(payload)
+		case ConversationEntryKind.ContextSummary:
+			return ContextSummaryPayload.assert(payload)
+		case ConversationEntryKind.ToolCall:
+		case ConversationEntryKind.ToolResult:
+		case ConversationEntryKind.SystemNote:
+			return GenericObjectPayload.assert(payload)
+	}
+}
+
+async function appendEntryToConversation(
+	db: Database,
+	userId: string | null,
+	conversationId: string,
+	input: AppendConversationEntryInput,
+): Promise<ConversationEntryRow> {
+	const kind = conversationEntryKind.assert(input.kind)
+	const visibility = conversationEntryVisibility.assert(
+		input.visibility ?? defaultVisibilityForKind(kind),
+	)
+	const payload = payloadForKind(kind, input.payload)
+	const metadata = ConversationEntryMetadata.assert(input.metadata ?? {})
+	let fileId: string | null = null
+
+	if (input.kind === ConversationEntryKind.Attachment) {
+		fileId = input.fileId
+	}
+
+	const conversation = userId
+		? await findConversationForUpdate(db, userId, conversationId)
+		: await findConversationByIdForUpdate(db, conversationId)
+	if (!conversation) {
+		throw new ConversationNotFoundError(conversationId, userId ?? "")
+	}
+	if (fileId) await requireFile(db, conversation.userId, fileId)
+
+	const sequence = await nextSequence(db, conversationId)
+	const rows = await db
+		.insert(conversationEntries)
+		.values({
+			conversationId,
+			sequence,
+			kind,
+			visibility,
+			fileId,
+			payload,
+			metadata,
+		})
+		.returning()
+
+	await touchConversation(db, conversation.userId, conversationId)
+	return requireRow(rows)
+}
+
+async function appendAttachmentEntryToConversation(
+	db: Database,
+	userId: string | null,
+	conversationId: string,
+	input: AppendAttachmentEntryInput,
+): Promise<AppendAttachmentEntryResult> {
+	const payload = AttachmentPayload.assert(input.payload)
+	const visibility = conversationEntryVisibility.assert(
+		input.visibility ?? defaultVisibilityForKind(ConversationEntryKind.Attachment),
+	)
+	const metadata = ConversationEntryMetadata.assert(input.metadata ?? {})
+	const conversation = userId
+		? await findConversationForUpdate(db, userId, conversationId)
+		: await findConversationByIdForUpdate(db, conversationId)
+
+	if (!conversation) {
+		throw new ConversationNotFoundError(conversationId, userId ?? "")
+	}
+
+	const file = await insertFile(db, conversation.userId, input.file)
+	const sequence = await nextSequence(db, conversationId)
+	const rows = await db
+		.insert(conversationEntries)
+		.values({
+			conversationId,
+			sequence,
+			kind: ConversationEntryKind.Attachment,
+			visibility,
+			fileId: file.id,
+			payload,
+			metadata,
+		})
+		.returning()
+
+	await touchConversation(db, conversation.userId, conversationId)
+	return {
+		file,
+		entry: requireRow(rows),
+	}
+}
+
+async function requireUserForUpdate(db: Database, userId: string): Promise<void> {
+	const rows = await db
+		.select({ id: user.id })
+		.from(user)
+		.where(eq(user.id, userId))
+		.limit(1)
+		.for("update")
+
+	requireRow(rows, `User not found: ${userId}`)
+}
+
+export async function findConversation(
+	db: Database,
+	conversationId: string,
+): Promise<ConversationRow | null> {
+	const rows = await db
+		.select()
+		.from(conversationsTable)
+		.where(eq(conversationsTable.id, conversationId))
+		.limit(1)
+
+	return rows[0] ?? null
+}
+
+async function findUserConversation(
+	db: Database,
+	userId: string,
+	conversationId: string,
+): Promise<ConversationRow | null> {
+	const rows = await db
+		.select()
+		.from(conversationsTable)
+		.where(and(eq(conversationsTable.id, conversationId), eq(conversationsTable.userId, userId)))
+		.limit(1)
+
+	return rows[0] ?? null
+}
+
+async function findConversationForUpdate(
+	db: Database,
+	userId: string,
+	conversationId: string,
+): Promise<ConversationRow | null> {
+	const rows = await db
+		.select()
+		.from(conversationsTable)
+		.where(and(eq(conversationsTable.id, conversationId), eq(conversationsTable.userId, userId)))
+		.limit(1)
+		.for("update")
+
+	return rows[0] ?? null
+}
+
+async function findConversationByIdForUpdate(
+	db: Database,
+	conversationId: string,
+): Promise<ConversationRow | null> {
+	const rows = await db
+		.select()
+		.from(conversationsTable)
+		.where(eq(conversationsTable.id, conversationId))
+		.limit(1)
+		.for("update")
+
+	return rows[0] ?? null
+}
+
+async function latestConversation(db: Database, userId: string): Promise<ConversationRow | null> {
+	const rows = await db
+		.select()
+		.from(conversationsTable)
+		.where(eq(conversationsTable.userId, userId))
+		.orderBy(desc(conversationsTable.updatedAt), desc(conversationsTable.createdAt))
+		.limit(1)
+
+	return rows[0] ?? null
+}
+
+async function insertConversation(db: Database, userId: string): Promise<ConversationRow> {
+	const rows = await db
+		.insert(conversationsTable)
+		.values({
+			userId,
+		})
+		.returning()
+
+	return requireRow(rows)
+}
+
+async function requireFile(db: Database, userId: string, fileId: string): Promise<FileRow> {
+	const rows = await db
+		.select()
+		.from(files)
+		.where(and(eq(files.id, fileId), eq(files.userId, userId)))
+		.limit(1)
+
+	return requireRow(rows, `File not found: ${fileId}`)
+}
+
+async function insertFile(db: Database, userId: string, input: CreateFileInput): Promise<FileRow> {
+	const rows = await db
+		.insert(files)
+		.values({
+			userId,
+			storageKey: input.storageKey,
+			originalName: input.originalName ?? null,
+			mimeType: input.mimeType,
+			sizeBytes: input.sizeBytes,
+			metadata: input.metadata ?? {},
+		})
+		.returning()
+
+	return requireRow(rows)
+}
+
+async function touchConversation(
+	db: Database,
+	userId: string,
+	conversationId: string,
+): Promise<void> {
+	await db
+		.update(conversationsTable)
+		.set({ updatedAt: new Date() })
+		.where(and(eq(conversationsTable.id, conversationId), eq(conversationsTable.userId, userId)))
+}
+
+async function nextSequence(db: Database, conversationId: string): Promise<number> {
+	const rows = await db
+		.select({ sequence: conversationEntries.sequence })
+		.from(conversationEntries)
+		.where(eq(conversationEntries.conversationId, conversationId))
+		.orderBy(desc(conversationEntries.sequence))
+		.limit(1)
+
+	return (rows[0]?.sequence ?? 0) + 1
+}
+
+function requireRow<T>(rows: T[], message = "Expected database row"): T {
+	const row = rows[0]
+	if (!row) throw new Error(message)
+	return row
+}
+
+function defaultVisibilityForKind(kind: ConversationEntryKind): ConversationEntryVisibility {
+	switch (kind) {
+		case ConversationEntryKind.UserMessage:
+		case ConversationEntryKind.AssistantMessage:
+		case ConversationEntryKind.Attachment:
+			return ConversationEntryVisibility.UserVisible
+		case ConversationEntryKind.ToolCall:
+		case ConversationEntryKind.ToolResult:
+		case ConversationEntryKind.ContextSummary:
+		case ConversationEntryKind.SystemNote:
+			return ConversationEntryVisibility.Internal
+	}
+}

apps/freya-backend/src/conversations/http.test.ts

@@ -25,7 +25,7 @@ const listEntriesCalls: Array<{
 	params: ListConversationEntriesParams
 }> = []
 
-mock.module("./storage.ts", () => ({
+mock.module("./db-storage.ts", () => ({
 	conversations: (_db: Database, userId: string) => ({
 		async listConversations(): Promise<ConversationRow[]> {
 			return conversationRowsByUser.get(userId) ?? []

apps/freya-backend/src/conversations/http.ts

@@ -1,6 +1,10 @@
 import type { Context, Hono } from "hono"
 
-import { ConversationEntryVisibility } from "@freya/core"
+import {
+	ConversationEntryVisibility,
+	type Conversation,
+	type ConversationEntry,
+} from "@freya/core"
 import { type } from "arktype"
 import { createMiddleware } from "hono/factory"
 
@@ -8,8 +12,9 @@ import type { AuthSessionMiddleware } from "../auth/session-middleware.ts"
 import type { Database } from "../db/index.ts"
 import type { ConversationRow } from "./storage.ts"
 
+import { conversations } from "./db-storage.ts"
 import { ConversationNotFoundError } from "./errors.ts"
-import { conversations } from "./storage.ts"
+import { conversationEntryFromRow } from "./serialization.ts"
 
 /** Hono environment populated by the conversations route middleware. */
 type Env = {
@@ -18,19 +23,20 @@ type Env = {
 	}
 }
 
-/** Serialized conversation summary returned by the list endpoint. */
-interface ConversationSummaryResponse {
-	id: string
-	createdAt: string
-	updatedAt: string
-}
-
 /** Dependencies required to register conversation HTTP handlers. */
 interface ConversationsHttpHandlersDeps {
 	db: Database
 	authSessionMiddleware: AuthSessionMiddleware
 }
 
+interface ListConversationsResponse {
+	conversations: Conversation[]
+}
+
+interface ListConversationEntriesResponse {
+	entries: ConversationEntry[]
+}
+
 const ConversationIdParam = type("string.uuid")
 
 export function registerConversationsHttpHandlers(
@@ -49,12 +55,13 @@ export function registerConversationsHttpHandlers(
 async function handleListConversations(c: Context<Env>) {
 	const user = c.get("user")!
 	const db = c.get("db")
-
+	const response: ListConversationsResponse = {
-	return c.json({
 		conversations: (await conversations(db, user.id).listConversations()).map(
 			serializeConversation,
 		),
-	})
+	}
+
+	return c.json(response)
 }
 
 async function handleListEntries(c: Context<Env>) {
@@ -73,20 +80,11 @@ async function handleListEntries(c: Context<Env>) {
 		const entries = await conversations(db, user.id).listEntries(parsedConversationId, {
 			visibility: ConversationEntryVisibility.UserVisible,
 		})
+		const response: ListConversationEntriesResponse = {
+			entries: entries.map(conversationEntryFromRow),
+		}
 
-		return c.json({
+		return c.json(response)
-			entries: entries.map((row) => ({
-				id: row.id,
-				conversationId: row.conversationId,
-				sequence: row.sequence,
-				kind: row.kind,
-				visibility: row.visibility,
-				fileId: row.fileId,
-				payload: row.payload,
-				metadata: row.metadata,
-				createdAt: row.createdAt.toISOString(),
-			})),
-		})
 	} catch (err) {
 		if (err instanceof ConversationNotFoundError) {
 			return c.json({ error: "Conversation not found" }, 404)
@@ -95,7 +93,7 @@ async function handleListEntries(c: Context<Env>) {
 	}
 }
 
-function serializeConversation(row: ConversationRow): ConversationSummaryResponse {
+function serializeConversation(row: ConversationRow): Conversation {
 	return {
 		id: row.id,
 		createdAt: row.createdAt.toISOString(),

apps/freya-backend/src/conversations/serialization.ts

@@ -0,0 +1,90 @@
+import {
+	AssistantMessagePayload,
+	AttachmentPayload,
+	ConversationEntryKind,
+	ContextSummaryPayload,
+	GenericObjectPayload,
+	UserMessagePayload,
+	type ConversationEntry,
+} from "@freya/core"
+
+import type { ConversationEntryRow } from "./storage.ts"
+
+export function conversationEntryFromRow(row: ConversationEntryRow): ConversationEntry {
+	const base = {
+		id: row.id,
+		conversationId: row.conversationId,
+		sequence: row.sequence,
+		visibility: row.visibility,
+		metadata: row.metadata,
+		createdAt: row.createdAt.toISOString(),
+	}
+
+	switch (row.kind) {
+		case ConversationEntryKind.UserMessage:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: nullFileId(row),
+				payload: UserMessagePayload.assert(row.payload),
+			}
+		case ConversationEntryKind.AssistantMessage:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: nullFileId(row),
+				payload: AssistantMessagePayload.assert(row.payload),
+			}
+		case ConversationEntryKind.Attachment:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: requireFileId(row),
+				payload: AttachmentPayload.assert(row.payload),
+			}
+		case ConversationEntryKind.ToolCall:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: nullFileId(row),
+				payload: GenericObjectPayload.assert(row.payload),
+			}
+		case ConversationEntryKind.ToolResult:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: nullFileId(row),
+				payload: GenericObjectPayload.assert(row.payload),
+			}
+		case ConversationEntryKind.ContextSummary:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: nullFileId(row),
+				payload: ContextSummaryPayload.assert(row.payload),
+			}
+		case ConversationEntryKind.SystemNote:
+			return {
+				...base,
+				kind: row.kind,
+				fileId: nullFileId(row),
+				payload: GenericObjectPayload.assert(row.payload),
+			}
+	}
+}
+
+function requireFileId(row: ConversationEntryRow): string {
+	if (!row.fileId) {
+		throw new Error(`Conversation attachment entry "${row.id}" is missing a file id`)
+	}
+
+	return row.fileId
+}
+
+function nullFileId(row: ConversationEntryRow): null {
+	if (row.fileId !== null) {
+		throw new Error(`Conversation entry "${row.id}" unexpectedly references a file`)
+	}
+
+	return null
+}

apps/freya-backend/src/conversations/storage.ts

@@ -2,28 +2,71 @@ import {
 	AssistantMessagePayload,
 	AttachmentPayload,
 	ConversationEntryKind,
+	ConversationEntryMetadata,
 	ConversationEntryVisibility,
 	ContextSummaryPayload,
-	ConversationEntryMetadata,
 	GenericObjectPayload,
 	UserMessagePayload,
-	type ConversationEntryPayload,
+	type ConversationEntry,
 } from "@freya/core"
-import { type } from "arktype"
-import { and, asc, desc, eq } from "drizzle-orm"
-
-import type { Database } from "../db/index.ts"
 
 import {
 	conversationEntries,
+	conversationResponseState as conversationResponseStateTable,
 	conversations as conversationsTable,
 	files,
-	user,
+	type ConversationResponseStateStatus,
 } from "../db/schema.ts"
-import { ConversationNotFoundError } from "./errors.ts"
 
-const conversationEntryKind = type.enumerated(...Object.values(ConversationEntryKind))
+export interface ConversationStorage {
-const conversationEntryVisibility = type.enumerated(...Object.values(ConversationEntryVisibility))
+	transaction<T>(tx: (storage: ConversationStorage) => T | Promise<T>): Promise<T>
+	createConversation(userId: string): Promise<ConversationRow>
+	listUserConversations(userId: string): Promise<ConversationRow[]>
+	findConversation(conversationId: string): Promise<ConversationRow | null>
+	getOrCreateConversation(userId: string): Promise<ConversationRow>
+	createFile(userId: string, input: CreateFileInput): Promise<FileRow>
+	appendEntry(
+		conversationId: string,
+		input: AppendConversationEntryInput,
+	): Promise<ConversationEntry>
+	appendAttachmentEntry(
+		conversationId: string,
+		input: AppendAttachmentEntryInput,
+	): Promise<AppendAttachmentEntryResult>
+	nextSequence(conversationId: string): Promise<number>
+	listUserConversationEntries(
+		userId: string,
+		conversationId: string,
+		params?: ListConversationEntriesParams,
+	): Promise<ConversationEntryRow[]>
+	listPendingUserConversationEntries(
+		userId: string,
+		conversationId: string,
+	): Promise<ConversationEntryRow[]>
+	findConversationResponseState(
+		conversationId: string,
+	): Promise<ConversationResponseStateRow | null>
+	// TODO: add pagination support
+	listPendingResponseStates(): Promise<ConversationResponseStateRow[]>
+	// TODO: add pagination support
+	listRunningResponseStates(): Promise<ConversationResponseStateRow[]>
+	upsertConversationResponseState(
+		conversationId: string,
+		input: UpsertConversationResponseStateInput,
+	): Promise<ConversationResponseStateRow>
+	updateConversationResponseState(
+		conversationId: string,
+		input: UpdateConversationResponseStateInput,
+	): Promise<ConversationResponseStateRow | null>
+	markResponseStateStatus(
+		conversationIds: string[],
+		status: ConversationResponseStateStatus,
+	): Promise<ConversationResponseStateRow[]>
+	claimPendingConversationResponseState(
+		conversationId: string,
+	): Promise<ConversationResponseStateRow | null>
+	clearConversationResponseState(conversationId: string): Promise<void>
+}
 
 /** Database row shape for a conversation owned by a user. */
 export type ConversationRow = typeof conversationsTable.$inferSelect
@@ -31,6 +74,9 @@ export type ConversationRow = typeof conversationsTable.$inferSelect
 /** Database row shape for an entry in a conversation timeline. */
 export type ConversationEntryRow = typeof conversationEntries.$inferSelect
 
+/** Database row shape for pending assistant response state in a conversation. */
+export type ConversationResponseStateRow = typeof conversationResponseStateTable.$inferSelect
+
 /** Database row shape for an uploaded file referenced by conversations. */
 export type FileRow = typeof files.$inferSelect
 
@@ -99,291 +145,26 @@ export interface ListConversationEntriesParams {
 	visibility?: ConversationEntryVisibility
 }
 
-export function conversations(db: Database, userId: string) {
+/** Input for creating or replacing pending assistant response state. */
-	const storage = {
+export interface UpsertConversationResponseStateInput {
-		async createConversation(): Promise<ConversationRow> {
+	status?: ConversationResponseStateStatus
-			return insertConversation(db, userId)
+	pendingSinceEntryId: string
-		},
+	maxWaitUntil: Date
-
+	runningSince?: Date | null
-		async listConversations(): Promise<ConversationRow[]> {
-			return db
-				.select()
-				.from(conversationsTable)
-				.where(eq(conversationsTable.userId, userId))
-				.orderBy(desc(conversationsTable.updatedAt), desc(conversationsTable.createdAt))
-		},
-
-		async getConversation(conversationId: string): Promise<ConversationRow | null> {
-			const rows = await db
-				.select()
-				.from(conversationsTable)
-				.where(
-					and(eq(conversationsTable.id, conversationId), eq(conversationsTable.userId, userId)),
-				)
-				.limit(1)
-
-			return rows[0] ?? null
-		},
-
-		async getOrCreateConversation(): Promise<ConversationRow> {
-			return db.transaction(async (tx) => {
-				await requireUserForUpdate(tx, userId)
-				const existing = await latestConversation(tx, userId)
-				if (existing) return existing
-
-				return insertConversation(tx, userId)
-			})
-		},
-
-		async createFile(input: CreateFileInput): Promise<FileRow> {
-			return insertFile(db, userId, input)
-		},
-
-		async appendEntry(
-			conversationId: string,
-			input: AppendConversationEntryInput,
-		): Promise<ConversationEntryRow> {
-			const kind = conversationEntryKind.assert(input.kind)
-			const visibility = conversationEntryVisibility.assert(
-				input.visibility ?? defaultVisibilityForKind(kind),
-			)
-			const payload = payloadForKind(kind, input.payload)
-			const metadata = ConversationEntryMetadata.assert(input.metadata ?? {})
-			let fileId: string | null = null
-
-			if (input.kind === ConversationEntryKind.Attachment) {
-				fileId = input.fileId
-				await requireFile(db, userId, fileId)
-			}
-
-			const rows = await db.transaction(async (tx) => {
-				if (!(await findConversationForUpdate(tx, userId, conversationId))) {
-					throw new ConversationNotFoundError(conversationId, userId)
-				}
-				const sequence = await nextSequence(tx, conversationId)
-
-				const rows = await tx
-					.insert(conversationEntries)
-					.values({
-						conversationId,
-						sequence,
-						kind,
-						visibility,
-						fileId,
-						payload,
-						metadata,
-					})
-					.returning()
-
-				await touchConversation(tx, userId, conversationId)
-				return rows
-			})
-
-			return requireRow(rows)
-		},
-
-		async appendAttachmentEntry(
-			conversationId: string,
-			input: AppendAttachmentEntryInput,
-		): Promise<AppendAttachmentEntryResult> {
-			const payload = AttachmentPayload.assert(input.payload)
-			const visibility = conversationEntryVisibility.assert(
-				input.visibility ?? defaultVisibilityForKind(ConversationEntryKind.Attachment),
-			)
-			const metadata = ConversationEntryMetadata.assert(input.metadata ?? {})
-
-			return db.transaction(async (tx) => {
-				if (!(await findConversationForUpdate(tx, userId, conversationId))) {
-					throw new ConversationNotFoundError(conversationId, userId)
-				}
-
-				const file = await insertFile(tx, userId, input.file)
-				const sequence = await nextSequence(tx, conversationId)
-				const rows = await tx
-					.insert(conversationEntries)
-					.values({
-						conversationId,
-						sequence,
-						kind: ConversationEntryKind.Attachment,
-						visibility,
-						fileId: file.id,
-						payload,
-						metadata,
-					})
-					.returning()
-
-				await touchConversation(tx, userId, conversationId)
-				return {
-					file,
-					entry: requireRow(rows),
-				}
-			})
-		},
-
-		async listEntries(
-			conversationId: string,
-			params: ListConversationEntriesParams = {},
-		): Promise<ConversationEntryRow[]> {
-			if (!(await storage.getConversation(conversationId))) {
-				throw new ConversationNotFoundError(conversationId, userId)
-			}
-
-			if (params.visibility) {
-				return db
-					.select()
-					.from(conversationEntries)
-					.where(
-						and(
-							eq(conversationEntries.conversationId, conversationId),
-							eq(conversationEntries.visibility, params.visibility),
-						),
-					)
-					.orderBy(asc(conversationEntries.sequence))
-			}
-
-			return db
-				.select()
-				.from(conversationEntries)
-				.where(eq(conversationEntries.conversationId, conversationId))
-				.orderBy(asc(conversationEntries.sequence))
-		},
-	}
-
-	return storage
 }
 
-function payloadForKind(
+/** Input for patching pending assistant response state. */
-	kind: ConversationEntryKind,
+export interface UpdateConversationResponseStateInput {
-	payload: AppendConversationEntryInput["payload"],
+	status?: ConversationResponseStateStatus
-): ConversationEntryPayload {
+	pendingSinceEntryId?: string
-	switch (kind) {
+	maxWaitUntil?: Date
-		case ConversationEntryKind.UserMessage:
+	runningSince?: Date | null
-			return UserMessagePayload.assert(payload)
-		case ConversationEntryKind.AssistantMessage:
-			return AssistantMessagePayload.assert(payload)
-		case ConversationEntryKind.Attachment:
-			return AttachmentPayload.assert(payload)
-		case ConversationEntryKind.ContextSummary:
-			return ContextSummaryPayload.assert(payload)
-		case ConversationEntryKind.ToolCall:
-		case ConversationEntryKind.ToolResult:
-		case ConversationEntryKind.SystemNote:
-			return GenericObjectPayload.assert(payload)
-	}
 }
 
-async function requireUserForUpdate(db: Database, userId: string): Promise<void> {
+export {
-	const rows = await db
+	createConversationStorage,
-		.select({ id: user.id })
+	conversationResponse,
-		.from(user)
+	conversations,
-		.where(eq(user.id, userId))
+	DrizzleConversationStorage,
-		.limit(1)
+	findConversation,
-		.for("update")
+} from "./db-storage.ts"
-
-	requireRow(rows, `User not found: ${userId}`)
-}
-
-async function findConversationForUpdate(
-	db: Database,
-	userId: string,
-	conversationId: string,
-): Promise<ConversationRow | null> {
-	const rows = await db
-		.select()
-		.from(conversationsTable)
-		.where(and(eq(conversationsTable.id, conversationId), eq(conversationsTable.userId, userId)))
-		.limit(1)
-		.for("update")
-
-	return rows[0] ?? null
-}
-
-async function latestConversation(db: Database, userId: string): Promise<ConversationRow | null> {
-	const rows = await db
-		.select()
-		.from(conversationsTable)
-		.where(eq(conversationsTable.userId, userId))
-		.orderBy(desc(conversationsTable.updatedAt), desc(conversationsTable.createdAt))
-		.limit(1)
-
-	return rows[0] ?? null
-}
-
-async function insertConversation(db: Database, userId: string): Promise<ConversationRow> {
-	const rows = await db
-		.insert(conversationsTable)
-		.values({
-			userId,
-		})
-		.returning()
-
-	return requireRow(rows)
-}
-
-async function requireFile(db: Database, userId: string, fileId: string): Promise<FileRow> {
-	const rows = await db
-		.select()
-		.from(files)
-		.where(and(eq(files.id, fileId), eq(files.userId, userId)))
-		.limit(1)
-
-	return requireRow(rows, `File not found: ${fileId}`)
-}
-
-async function insertFile(db: Database, userId: string, input: CreateFileInput): Promise<FileRow> {
-	const rows = await db
-		.insert(files)
-		.values({
-			userId,
-			storageKey: input.storageKey,
-			originalName: input.originalName ?? null,
-			mimeType: input.mimeType,
-			sizeBytes: input.sizeBytes,
-			metadata: input.metadata ?? {},
-		})
-		.returning()
-
-	return requireRow(rows)
-}
-
-async function touchConversation(
-	db: Database,
-	userId: string,
-	conversationId: string,
-): Promise<void> {
-	await db
-		.update(conversationsTable)
-		.set({ updatedAt: new Date() })
-		.where(and(eq(conversationsTable.id, conversationId), eq(conversationsTable.userId, userId)))
-}
-
-async function nextSequence(db: Database, conversationId: string): Promise<number> {
-	const rows = await db
-		.select({ sequence: conversationEntries.sequence })
-		.from(conversationEntries)
-		.where(eq(conversationEntries.conversationId, conversationId))
-		.orderBy(desc(conversationEntries.sequence))
-		.limit(1)
-
-	return (rows[0]?.sequence ?? 0) + 1
-}
-
-function requireRow<T>(rows: T[], message = "Expected database row"): T {
-	const row = rows[0]
-	if (!row) throw new Error(message)
-	return row
-}
-
-function defaultVisibilityForKind(kind: ConversationEntryKind): ConversationEntryVisibility {
-	switch (kind) {
-		case ConversationEntryKind.UserMessage:
-		case ConversationEntryKind.AssistantMessage:
-		case ConversationEntryKind.Attachment:
-			return ConversationEntryVisibility.UserVisible
-		case ConversationEntryKind.ToolCall:
-		case ConversationEntryKind.ToolResult:
-		case ConversationEntryKind.ContextSummary:
-		case ConversationEntryKind.SystemNote:
-			return ConversationEntryVisibility.Internal
-	}
-}

apps/freya-backend/src/db/schema.ts

@@ -48,6 +48,15 @@ const bytea = customType<{ data: Buffer }>({
 	},
 })
 
+export const ConversationResponseStateStatus = {
+	Pending: "pending",
+	Running: "running",
+	Failed: "failed",
+} as const
+
+export type ConversationResponseStateStatus =
+	(typeof ConversationResponseStateStatus)[keyof typeof ConversationResponseStateStatus]
+
 export const userSources = pgTable(
 	"user_sources",
 	{
@@ -146,6 +155,38 @@ export const conversationEntries = pgTable(
 	],
 )
 
+export const conversationResponseState = pgTable(
+	"conversation_response_state",
+	{
+		conversationId: uuid("conversation_id")
+			.primaryKey()
+			.references(() => conversations.id, { onDelete: "cascade" }),
+		status: text("status")
+			.$type<ConversationResponseStateStatus>()
+			.notNull()
+			.default(ConversationResponseStateStatus.Pending),
+		pendingSinceEntryId: uuid("pending_since_entry_id")
+			.notNull()
+			.references(() => conversationEntries.id, { onDelete: "cascade" }),
+		maxWaitUntil: timestamp("max_wait_until").notNull(),
+		runningSince: timestamp("running_since"),
+		createdAt: timestamp("created_at").notNull().defaultNow(),
+		updatedAt: timestamp("updated_at")
+			.notNull()
+			.defaultNow()
+			.$onUpdate(() => new Date()),
+	},
+	(t) => [
+		index("conversation_response_state_status_max_wait_until_idx").on(t.status, t.maxWaitUntil),
+		index("conversation_response_state_running_since_idx").on(t.runningSince),
+		index("conversation_response_state_pending_since_entry_id_idx").on(t.pendingSinceEntryId),
+		check(
+			"conversation_response_state_status_check",
+			sql`${t.status} in ('pending', 'running', 'failed')`,
+		),
+	],
+)
+
 // ---------------------------------------------------------------------------
 // FREYA — reminders source storage
 // ---------------------------------------------------------------------------

apps/freya-backend/src/engine/http.test.ts

@@ -14,7 +14,6 @@ interface FeedResponse {
 	items: Array<{
 		id: string
 		type: string
-		priority: number
 		timestamp: string
 		data: Record<string, unknown>
 	}>
@@ -85,7 +84,7 @@ mock.module("../sources/user-sources.ts", () => ({
 	}),
 }))
 
-mock.module("../conversations/storage.ts", () => ({
+mock.module("../conversations/db-storage.ts", () => ({
 	conversations: (_db: Database, userId: string) => ({
 		async getOrCreateConversation() {
 			return { id: `conversation-${userId}` }
@@ -118,7 +117,6 @@ describe("GET /api/feed", () => {
 				id: "item-1",
 				sourceId: "test",
 				type: "test",
-				priority: 0.8,
 				timestamp: new Date("2025-01-01T00:00:00.000Z"),
 				data: { value: 42 },
 			},
@@ -149,7 +147,6 @@ describe("GET /api/feed", () => {
 		expect(body.items).toHaveLength(1)
 		expect(body.items[0]!.id).toBe("item-1")
 		expect(body.items[0]!.type).toBe("test")
-		expect(body.items[0]!.priority).toBe(0.8)
 		expect(body.items[0]!.timestamp).toBe("2025-01-01T00:00:00.000Z")
 		expect(body.errors).toHaveLength(0)
 	})
@@ -160,7 +157,6 @@ describe("GET /api/feed", () => {
 				id: "fresh-1",
 				sourceId: "test",
 				type: "test",
-				priority: 0.5,
 				timestamp: new Date("2025-06-01T12:00:00.000Z"),
 				data: { fresh: true },
 			},

apps/freya-backend/src/enhancement/schema.test.ts

@@ -135,8 +135,9 @@ describe("schema sync", () => {
 
 			// JSON Schema structure matches
 			const jsonSchema = enhancementResultJsonSchema
+			const payloadKeys = Object.keys(payload).sort() as Array<(typeof jsonSchema.required)[number]>
 			expect(Object.keys(jsonSchema.properties).sort()).toEqual(Object.keys(payload).sort())
-			expect([...jsonSchema.required].sort()).toEqual(Object.keys(payload).sort())
+			expect([...jsonSchema.required].sort()).toEqual(payloadKeys)
 
 			// syntheticItems item schema has the right required fields
 			const itemSchema = jsonSchema.properties.syntheticItems.items

apps/freya-backend/src/lib/job.ts

@@ -0,0 +1,116 @@
+import { Queue } from "./queue"
+
+const JobStatus = {
+	Pending: "pending",
+	Running: "running",
+} as const
+type JobStatus = (typeof JobStatus)[keyof typeof JobStatus]
+
+export interface Job<Payload> {
+	id: number
+	payload: Payload
+	signal: AbortSignal
+}
+
+interface PendingJob<Payload> {
+	status: typeof JobStatus.Pending
+	controller: AbortController
+	job: Job<Payload>
+}
+
+interface RunningJob<Payload> {
+	status: typeof JobStatus.Running
+	controller: AbortController
+	job: Job<Payload>
+}
+
+type JobState<Payload> = PendingJob<Payload> | RunningJob<Payload>
+
+type JobEventListener<Payload> = (job: Job<Payload>) => void
+
+type JobEvent = "settled" | "cancelled"
+
+export class JobRegistry<Payload> {
+	private queue = new Queue<Job<Payload>>()
+
+	private states = new Map<number, JobState<Payload>>()
+
+	private listeners: Record<JobEvent, JobEventListener<Payload>[]> = {
+		settled: [],
+		cancelled: [],
+	}
+
+	addJob({ payload }: { payload: Payload }): Job<Payload> {
+		const controller = new AbortController()
+		const job: Job<Payload> = {
+			id: this.generateJobId(),
+			payload,
+			signal: controller.signal,
+		}
+		this.queue.enqueue(job)
+		this.states.set(job.id, { status: JobStatus.Pending, controller, job })
+		return job
+	}
+
+	async nextJob(signal?: AbortSignal): Promise<Job<Payload> | null> {
+		while (true) {
+			const job = await this.queue.next(signal)
+			if (!job) {
+				return null
+			}
+
+			const state = this.states.get(job.id)
+
+			if (!state || state.job !== job || state.status === JobStatus.Running) {
+				continue
+			}
+			if (state.controller.signal.aborted) {
+				this.states.delete(job.id)
+				continue
+			}
+
+			this.states.set(job.id, { status: JobStatus.Running, controller: state.controller, job })
+
+			return job
+		}
+	}
+
+	cancelJob(job: Job<unknown>): void {
+		const state = this.states.get(job.id)
+		if (state?.job === job) {
+			state?.controller.abort()
+			this.notifyListeners("cancelled", job.id)
+			this.states.delete(job.id)
+		}
+	}
+
+	markJobAsCompleted(job: Job<unknown>): void {
+		const state = this.states.get(job.id)
+		if (state?.job === job) {
+			this.notifyListeners("settled", job.id)
+			this.states.delete(job.id)
+		}
+	}
+
+	addEventListener(event: JobEvent, listener: JobEventListener<Payload>): () => void {
+		this.listeners[event].push(listener)
+		return () => {
+			this.listeners[event] = this.listeners[event].filter((l) => l !== listener)
+		}
+	}
+
+	private generateJobId(): number {
+		let id: number
+		do {
+			id = Math.floor(Math.random() * 1000000)
+		} while (this.states.has(id))
+		return id
+	}
+
+	private notifyListeners(event: JobEvent, id: number): void {
+		const job = this.states.get(id)?.job
+		if (job) {
+			this.listeners[event].forEach((listener) => listener(job))
+		}
+	}
+}

apps/freya-backend/src/lib/queue.ts

@@ -0,0 +1,69 @@
+interface Item<T> {
+	value: T
+	next: Item<T> | null
+}
+
+export class Queue<T> {
+	private front: Item<T> | null = null
+	private back: Item<T> | null = null
+	private waiters: Array<(value: T) => void> = []
+
+	enqueue(value: T): void {
+		const waiter = this.waiters.shift()
+		if (waiter) {
+			waiter(value)
+			return
+		}
+
+		const newItem: Item<T> = { value, next: null }
+		if (this.back) {
+			this.back.next = newItem
+		} else {
+			this.front = newItem
+		}
+		this.back = newItem
+	}
+
+	dequeue(): T | null {
+		if (!this.front) return null
+		const value = this.front.value
+		this.front = this.front.next
+		if (!this.front) this.back = null
+		return value
+	}
+
+	next(signal?: AbortSignal): Promise<T | null> {
+		const value = this.dequeue()
+		if (value !== null) return Promise.resolve(value)
+
+		return new Promise((resolve) => {
+			if (signal) {
+				if (signal.aborted) {
+					resolve(null)
+				} else {
+					let _resolve: (v: T) => void
+
+					const onAbort = () => {
+						this.waiters = this.waiters.filter((w) => w !== _resolve)
+						resolve(null)
+					}
+
+					signal.addEventListener(
+						"abort",
+						onAbort,
+						{ once: true },
+					)
+
+					_resolve = (v: T) => {
+						signal.removeEventListener("abort", onAbort)
+						resolve(v)
+					}
+
+					this.waiters.push(_resolve)
+				}
+			} else {
+				this.waiters.push(resolve)
+			}
+		})
+	}
+}

apps/freya-backend/src/lib/worker.ts

@@ -0,0 +1,51 @@
+import type { Job, JobRegistry } from "./job"
+import type { Queue } from "./queue"
+
+export interface JobExecutor<JobPayload> {
+	execute(job: Job<JobPayload>): Promise<void>
+}
+
+export interface WorkerConfig<Job> {
+	concurrency: number
+	registry: JobRegistry<Job>
+	runner: JobExecutor<Job>
+	signal: AbortSignal
+}
+
+export class Worker<Job> {
+	private concurrency: number
+	private registry: JobRegistry<Job>
+	private runner: JobExecutor<Job>
+	private signal: AbortSignal
+
+	constructor({ concurrency, registry, runner, signal }: WorkerConfig<Job>) {
+		this.concurrency = concurrency
+		this.registry = registry
+		this.runner = runner
+		this.signal = signal
+	}
+
+	start() {
+		if (this.signal.aborted) return
+		for (let i = 0; i < this.concurrency; i++) {
+			void this.pollJobFromRegistry()
+		}
+	}
+
+	private async pollJobFromRegistry() {
+		while (!this.signal.aborted) {
+			const job = await this.registry.nextJob(this.signal)
+			if (!job) {
+				return
+			}
+
+			try {
+				await this.runner.execute(job)
+			} catch {
+				// TODO: handle logging of job execution errors
+			} finally {
+				this.registry.markJobAsCompleted(job)
+			}
+		}
+	}
+}

apps/freya-backend/src/notification/notification-central.ts

@@ -0,0 +1,36 @@
+import type { AgentEvent } from "@freya/agent-protocol"
+
+export interface AgentNotification {
+	kind: "agent"
+	payload: AgentEvent
+}
+
+export type NotificationPayload = AgentNotification
+export type NotificationListener = (notification: NotificationPayload) => Promise<void>
+
+export class NotificationCentral {
+	private listeners: Map<string, Set<NotificationListener>> = new Map()
+
+	registerListenerForUser(userId: string, listener: NotificationListener): () => void {
+		let listeners = this.listeners.get(userId)
+		if (!listeners) {
+			listeners = new Set()
+			this.listeners.set(userId, listeners)
+		}
+
+		listeners.add(listener)
+		return () => {
+			listeners.delete(listener)
+			if (listeners.size === 0) {
+				this.listeners.delete(userId)
+			}
+		}
+	}
+
+	async notifyUser(userId: string, notification: NotificationPayload): Promise<void> {
+		const listeners = this.listeners.get(userId)
+		if (!listeners) return
+
+		await Promise.allSettled(Array.from(listeners).map((listener) => listener(notification)))
+	}
+}

apps/freya-backend/src/server.ts

@@ -5,6 +5,7 @@ import { createMiddleware } from "hono/factory"
 import { registerAdminHttpHandlers } from "./admin/http.ts"
 import { createQueryDebugTools } from "./agent/debug-tools.ts"
 import { registerAgentHttpHandlers, registerDebugAgentHttpHandlers } from "./agent/http.ts"
+import { AgentService } from "./agent/service.ts"
 import { agentWebSocket, registerAgentWebSocketHandlers } from "./agent/ws.ts"
 import { createRequireAdmin } from "./auth/admin-middleware.ts"
 import { registerAuthHandlers } from "./auth/http.ts"
@@ -12,6 +13,7 @@ import { createAuth } from "./auth/index.ts"
 import { createRequireSession } from "./auth/session-middleware.ts"
 import { CalDavSourceProvider } from "./caldav/provider.ts"
 import { registerConversationsHttpHandlers } from "./conversations/http.ts"
+import { DrizzleConversationStorage } from "./conversations/storage.ts"
 import { createDatabase } from "./db/index.ts"
 import { registerFeedHttpHandlers } from "./engine/http.ts"
 import { createFeedEnhancer } from "./enhancement/enhance-feed.ts"
@@ -21,6 +23,7 @@ import { CredentialEncryptor } from "./lib/crypto.ts"
 import { ensureEnv } from "./lib/env.ts"
 import { registerLocationHttpHandlers } from "./location/http.ts"
 import { LocationSourceProvider } from "./location/provider.ts"
+import { NotificationCentral } from "./notification/notification-central.ts"
 import { ReminderSourceProvider } from "./reminders/provider.ts"
 import { UserSessionManager } from "./session/index.ts"
 import { registerSourcesHttpHandlers } from "./sources/http.ts"
@@ -32,8 +35,12 @@ function main() {
 	const env = ensureEnv(process.env)
 
 	const { db, close: closeDb } = createDatabase(env.databaseUrl)
+	const conversationStorage = new DrizzleConversationStorage(db, false)
+
 	const auth = createAuth(db)
 
+	const abortController = new AbortController()
+
 	const feedEnhancer = createFeedEnhancer({
 		client: createLlmClient({
 			apiKey: env.openrouterApiKey,
@@ -73,6 +80,15 @@ function main() {
 		console.warn("[query] PI_API_KEY or OPENROUTER_API_KEY not set — query agent unavailable")
 	}
 
+	const notificationCentral = new NotificationCentral()
+
+	const agentService = new AgentService({
+		notificationCentral,
+		storage: conversationStorage,
+		userSessionManager: sessionManager,
+		signal: abortController.signal,
+	})
+
 	const app = new Hono()
 
 	const isDev = process.env.NODE_ENV !== "production"
@@ -141,17 +157,22 @@ function main() {
 	registerAdminHttpHandlers(app, { sessionManager, adminMiddleware, db })
 
 	registerAgentWebSocketHandlers(app, {
-		sessionManager,
+		agentService,
+		notificationCentral,
+		storage: conversationStorage,
 		authSessionMiddleware,
 		corsMiddleware: agentWebSocketCorsMiddleware,
 	})
 
 	process.on("SIGTERM", async () => {
 		sessionManager.dispose()
+		abortController.abort()
 		await closeDb()
 		process.exit(0)
 	})
 
+	agentService.start()
+
 	return app
 }
 

apps/freya-backend/src/session/user-session-manager.test.ts

@@ -120,7 +120,7 @@ mock.module("../sources/user-sources.ts", () => ({
 	}),
 }))
 
-mock.module("../conversations/storage.ts", () => ({
+mock.module("../conversations/db-storage.ts", () => ({
 	conversations: (_db: Database, userId: string) => ({
 		async getOrCreateConversation(): Promise<{ id: string }> {
 			mockConversationCalls.push({ type: "getOrCreate", userId })

apps/freya-backend/src/session/user-session-manager.ts

@@ -8,7 +8,7 @@ import type { FeedEnhancer } from "../enhancement/enhance-feed.ts"
 import type { CredentialEncryptor } from "../lib/crypto.ts"
 import type { FeedSourceProvider } from "./feed-source-provider.ts"
 
-import { conversations } from "../conversations/storage.ts"
+import { conversations } from "../conversations/db-storage.ts"
 import {
 	CredentialStorageUnavailableError,
 	InvalidSourceConfigError,

apps/freya-backend/src/session/user-session.ts

@@ -263,18 +263,12 @@ export class UserSession {
 		const conversation = await conversationStorage.getOrCreateConversation()
 		const entries = await conversationStorage.listEntries(conversation.id)
 
-		this.queryAgent = new ConversationRecordingQueryAgent({
+		this.queryAgent = new PiQueryAgent({
-			agent: new PiQueryAgent({
+			toolbox: this.toolbox,
-				toolbox: this.toolbox,
+			apiKey: this.agentConfig?.apiKey,
-				apiKey: this.agentConfig?.apiKey,
+			cwd: this.agentConfig?.cwd,
-				cwd: this.agentConfig?.cwd,
+			systemPrompt: this.agentConfig?.systemPrompt,
-				systemPrompt: this.agentConfig?.systemPrompt,
+			initialEntries: entries,
-				initialEntries: entries,
-			}),
-			storage: conversationStorage,
-			defaultConversationId: conversation.id,
-			modelProvider: PI_MODEL_PROVIDER,
-			modelId: PI_MODEL_ID,
 		})
 	}
 

apps/freya-backend/src/sources/http.test.ts

@@ -128,7 +128,7 @@ mock.module("../sources/user-sources.ts", () => ({
 	},
 }))
 
-mock.module("../conversations/storage.ts", () => ({
+mock.module("../conversations/db-storage.ts", () => ({
 	conversations: (_db: Database, userId: string) => ({
 		async getOrCreateConversation() {
 			return { id: `conversation-${userId}` }

apps/freya-client/app.json

@@ -255,8 +255,7 @@
 				}
 			],
 			"expo-web-browser",
-			"expo-image",
+			"expo-image"
-			"expo-secure-store"
 		],
 		"experiments": {
 			"typedRoutes": true,

apps/freya-client/eas.json

@@ -6,16 +6,12 @@
 	"build": {
 		"development": {
 			"developmentClient": true,
-			"distribution": "internal",
+			"distribution": "internal"
-			"ios": {
-				"image": "sdk-56"
-			}
 		},
 		"development-simulator": {
 			"extends": "development",
 			"ios": {
-				"image": "sdk-56",
+				"simulator": "true"
-				"simulator": true
 			}
 		},
 		"preview": {

apps/freya-client/package.json

@@ -15,45 +15,29 @@
 		"debugger": "bun run scripts/open-debugger.ts"
 	},
 	"dependencies": {
-		"@better-auth/core": "^1.6.20",
-		"@better-auth/expo": "^1.6.20",
 		"@expo-google-fonts/inter": "^0.4.2",
 		"@expo-google-fonts/source-serif-4": "^0.4.1",
 		"@expo/vector-icons": "^15.0.3",
-		"@freya/core": "workspace:*",
 		"@json-render/react-native": "^0.13.0",
-		"@react-native-masked-view/masked-view": "0.3.2",
-		"@shopify/flash-list": "2.0.2",
 		"@tanstack/react-query": "^5.90.21",
-		"arktype": "^2.2.1",
-		"better-auth": "^1.6.20",
-		"class-variance-authority": "^0.7.1",
 		"expo": "^56.0.0",
-		"expo-blur": "~56.0.3",
 		"expo-constants": "~56.0.18",
 		"expo-dev-client": "~56.0.20",
 		"expo-font": "~56.0.7",
-		"expo-glass-effect": "~0.1.10",
 		"expo-haptics": "~56.0.3",
 		"expo-image": "~56.0.11",
-		"expo-linear-gradient": "~56.0.4",
 		"expo-linking": "~56.0.14",
 		"expo-location": "~56.0.18",
-		"expo-network": "~56.0.5",
 		"expo-router": "~56.2.11",
-		"expo-secure-store": "~56.0.4",
 		"expo-splash-screen": "~56.0.10",
 		"expo-status-bar": "~56.0.4",
 		"expo-symbols": "~56.0.6",
 		"expo-system-ui": "~56.0.5",
 		"expo-web-browser": "~56.0.5",
-		"jotai": "^2.20.1",
 		"react": "19.2.3",
 		"react-dom": "19.2.3",
 		"react-native": "0.85.3",
-		"react-native-easing-gradient": "^1.1.1",
 		"react-native-gesture-handler": "~2.31.1",
-		"react-native-keyboard-controller": "1.21.6",
 		"react-native-reanimated": "4.3.1",
 		"react-native-safe-area-context": "~5.7.0",
 		"react-native-screens": "4.25.2",

apps/freya-client/scripts/dev-proxy.ts

@@ -23,8 +23,6 @@ function forwardHeaders(headers: Headers): Headers {
 
 interface WsData {
 	upstream: WebSocket
-	upstreamUrl: string
-	path: string
 	isDevice: boolean
 }
 
@@ -44,10 +42,8 @@ Bun.serve<WsData>({
 
 		// WebSocket upgrade — bridge to Metro's ws endpoint
 		if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
-			const path = `${url.pathname}${url.search}`
+			const wsUrl = `${METRO_WS_BASE}${url.pathname}${url.search}`
-			const wsUrl = `${METRO_WS_BASE}${path}`
+			const upstream = new WebSocket(wsUrl)
-			console.log(`[proxy] ws connecting ${path}`)
-			const upstream = connectUpstreamWebSocket(wsUrl, getWebSocketHeaders(req, url))
 
 			// Wait for upstream to connect before upgrading the client
 			try {
@@ -60,7 +56,7 @@ Bun.serve<WsData>({
 			}
 
 			const isDevice = url.pathname.startsWith("/inspector/device")
-			const ok = server.upgrade(req, { data: { upstream, upstreamUrl: wsUrl, path, isDevice } })
+			const ok = server.upgrade(req, { data: { upstream, isDevice } })
 			if (!ok) {
 				upstream.close()
 				return new Response("WebSocket upgrade failed", { status: 500 })
@@ -87,28 +83,19 @@ Bun.serve<WsData>({
 
 	websocket: {
 		message(ws: ServerWebSocket<WsData>, msg) {
-			sendUpstream(ws.data.upstream, msg)
+			ws.data.upstream.send(msg)
 		},
 		open(ws: ServerWebSocket<WsData>) {
 			const { upstream } = ws.data
-			console.log(`[proxy] ws open ${ws.data.path}`)
 			upstream.addEventListener("message", (ev) => {
 				if (typeof ev.data === "string") {
 					ws.send(ev.data)
 				} else if (ev.data instanceof ArrayBuffer) {
 					ws.sendBinary(new Uint8Array(ev.data))
-				} else if (ev.data instanceof Blob) {
-					ev.data.arrayBuffer().then((buffer) => ws.sendBinary(new Uint8Array(buffer)))
 				}
 			})
-			upstream.addEventListener("close", (ev) => {
+			upstream.addEventListener("close", () => ws.close())
-				console.log(`[proxy] upstream close ${ws.data.path} code=${ev.code} reason=${ev.reason}`)
+			upstream.addEventListener("error", () => ws.close())
-				ws.close(ev.code, ev.reason)
-			})
-			upstream.addEventListener("error", () => {
-				console.error(`[proxy] upstream error ${ws.data.upstreamUrl}`)
-				ws.close()
-			})
 
 			// Print debugger URL shortly after a device connects,
 			// giving Metro time to register the target.
@@ -117,7 +104,6 @@ Bun.serve<WsData>({
 			}
 		},
 		close(ws: ServerWebSocket<WsData>) {
-			console.log(`[proxy] client close ${ws.data.path}`)
 			ws.data.upstream.close()
 		},
 	},
@@ -134,7 +120,7 @@ async function printDebuggerUrl() {
 	if (!Array.isArray(parsedTargets)) return
 
 	const targets = parsedTargets.filter(isDebugTarget)
-	const target = targets.find(prefersFuseboxFrontend) ?? targets[0]
+	const target = targets.find((t) => t.reactNative?.capabilities?.prefersFuseboxFrontend)
 	if (!target) return
 
 	const wsPath = getProxyWebSocketPath(target.webSocketDebuggerUrl)
@@ -167,29 +153,6 @@ async function fetchUpstream(
 	}
 }
 
-function sendUpstream(upstream: WebSocket, msg: string | Buffer) {
-	if (typeof msg === "string") {
-		upstream.send(msg)
-		return
-	}
-
-	upstream.send(new Uint8Array(msg))
-}
-
-function getWebSocketHeaders(req: Request, url: URL) {
-	return {
-		Origin: req.headers.get("origin") ?? url.origin,
-	}
-}
-
-function connectUpstreamWebSocket(url: string, headers: Record<string, string>) {
-	const BunWebSocket = WebSocket as unknown as {
-		new (url: string, options: { headers: Record<string, string> }): WebSocket
-	}
-
-	return new BunWebSocket(url, { headers })
-}
-
 function isDebugTarget(value: unknown): value is DebugTarget {
 	if (!isRecord(value) || typeof value.webSocketDebuggerUrl !== "string") return false
 
@@ -205,10 +168,6 @@ function isDebugTarget(value: unknown): value is DebugTarget {
 	return prefersFuseboxFrontend === undefined || typeof prefersFuseboxFrontend === "boolean"
 }
 
-function prefersFuseboxFrontend(target: DebugTarget) {
-	return target.reactNative?.capabilities?.prefersFuseboxFrontend === true
-}
-
 function getProxyWebSocketPath(webSocketDebuggerUrl: string) {
 	const url = new URL(webSocketDebuggerUrl)
 	return `${tsIp}:${PROXY_PORT}${url.pathname}${url.search}`

apps/freya-client/scripts/open-debugger.ts

@@ -29,7 +29,7 @@ if (!Array.isArray(parsedTargets)) {
 }
 
 const targets = parsedTargets.filter(isDebugTarget)
-const target = targets.find(prefersFuseboxFrontend) ?? targets[0]
+const target = targets.find((t) => t.reactNative?.capabilities?.prefersFuseboxFrontend)
 
 if (!target) {
 	console.error("No debug target found. Is the app connected?")
@@ -68,10 +68,6 @@ function isDebugTarget(value: unknown): value is DebugTarget {
 	return prefersFuseboxFrontend === undefined || typeof prefersFuseboxFrontend === "boolean"
 }
 
-function prefersFuseboxFrontend(target: DebugTarget) {
-	return target.reactNative?.capabilities?.prefersFuseboxFrontend === true
-}
-
 function getProxyWebSocketPath(webSocketDebuggerUrl: string) {
 	const url = new URL(webSocketDebuggerUrl)
 	return `${tsIp}:${PROXY_PORT}${url.pathname}${url.search}`

apps/freya-client/src/api/auth-middleware.ts

@@ -0,0 +1,6 @@
+import { ApiRequestMiddleware } from "./client"
+
+export const authMiddleware: ApiRequestMiddleware = (_url, init) => {
+	// TODO: placeholder auth middleware
+	return init
+}

apps/freya-client/src/api/client.ts

@@ -27,12 +27,9 @@ export class ApiClient {
 			(prevInit, middleware) => middleware(url, prevInit),
 			init,
 		)
-		return fetch(this.baseUrl ? this.baseUrl + url : url, finalInit)
+		return fetch(this.baseUrl ? new URL(url.toString(), this.baseUrl) : url, finalInit).then(
-			.then((res) => Promise.all([Promise.resolve(res), res.json()]))
+			(res) => Promise.all([Promise.resolve(res), res.json()]),
-			.catch((err) => {
+		)
-				console.log(`request error: ${url}`, err)
-				throw err
-			})
 	}
 }
 

apps/freya-client/src/app/(app)/index.tsx

@@ -1,134 +0,0 @@
-import { Link } from "expo-router"
-import { Pressable, ScrollView, View } from "react-native"
-import tw from "twrnc"
-
-import { FeedCard } from "@/components/ui/feed-card"
-import { MonospaceText } from "@/components/ui/monospace-text"
-import { SansSerifText } from "@/components/ui/sans-serif-text"
-import { SerifText } from "@/components/ui/serif-text"
-import { ChatOverlay } from "@/conversations/chat-overlay"
-
-export default function HomeScreen() {
-	return (
-		<View style={tw`bg-stone-100 dark:bg-stone-950 flex-1 relative`}>
-			<ScrollView
-				contentContainerStyle={tw`px-5 pt-6 pb-28 gap-3 justify-end flex-grow`}
-				showsVerticalScrollIndicator={false}
-			>
-				<FeedCard style={tw`bg-white dark:bg-stone-900 p-4 gap-3`}>
-					<View style={tw`flex-row items-center justify-between gap-3`}>
-						<SansSerifText style={tw`text-xs text-stone-500 dark:text-stone-400 uppercase`}>
-							Morning brief
-						</SansSerifText>
-						<MonospaceText style={tw`text-xs text-teal-700 dark:text-teal-300`}>
-							08:42
-						</MonospaceText>
-					</View>
-					<SerifText style={tw`text-3xl leading-9`}>
-						A calm start with two useful windows.
-					</SerifText>
-					<SansSerifText style={tw`text-base leading-6 text-stone-600 dark:text-stone-300`}>
-						Your morning is light until the project sync. Rain holds off until late afternoon, and
-						your last note suggests starting with the proposal outline.
-					</SansSerifText>
-					<View style={tw`flex-row flex-wrap gap-2`}>
-						<View style={tw`rounded-full bg-teal-50 dark:bg-teal-950 px-3 py-1`}>
-							<SansSerifText style={tw`text-xs text-teal-700 dark:text-teal-200`}>
-								90 min focus
-							</SansSerifText>
-						</View>
-						<View style={tw`rounded-full bg-stone-100 dark:bg-stone-800 px-3 py-1`}>
-							<SansSerifText style={tw`text-xs text-stone-600 dark:text-stone-300`}>
-								2 reminders
-							</SansSerifText>
-						</View>
-						<View style={tw`rounded-full bg-stone-100 dark:bg-stone-800 px-3 py-1`}>
-							<SansSerifText style={tw`text-xs text-stone-600 dark:text-stone-300`}>
-								Low email volume
-							</SansSerifText>
-						</View>
-					</View>
-				</FeedCard>
-
-				<FeedCard style={tw`bg-white dark:bg-stone-900 p-4 gap-4`}>
-					<View style={tw`flex-row items-baseline justify-between gap-3`}>
-						<SerifText style={tw`text-2xl`}>Next up</SerifText>
-						<SansSerifText style={tw`text-xs text-stone-500 dark:text-stone-400`}>
-							Today
-						</SansSerifText>
-					</View>
-					<View style={tw`gap-3`}>
-						<View style={tw`flex-row gap-3`}>
-							<MonospaceText style={tw`w-14 text-xs text-stone-500 dark:text-stone-400`}>
-								09:30
-							</MonospaceText>
-							<View style={tw`flex-1 gap-1`}>
-								<SansSerifText style={tw`font-semibold`}>Project sync prep</SansSerifText>
-								<SansSerifText style={tw`text-sm leading-5 text-stone-600 dark:text-stone-300`}>
-									Three notes from yesterday are ready to skim.
-								</SansSerifText>
-							</View>
-						</View>
-						<View style={tw`h-px bg-stone-200 dark:bg-stone-800`} />
-						<View style={tw`flex-row gap-3`}>
-							<MonospaceText style={tw`w-14 text-xs text-stone-500 dark:text-stone-400`}>
-								11:00
-							</MonospaceText>
-							<View style={tw`flex-1 gap-1`}>
-								<SansSerifText style={tw`font-semibold`}>Quiet work block</SansSerifText>
-								<SansSerifText style={tw`text-sm leading-5 text-stone-600 dark:text-stone-300`}>
-									Best slot for the proposal before the day gets busy.
-								</SansSerifText>
-							</View>
-						</View>
-					</View>
-				</FeedCard>
-
-				<FeedCard style={tw`bg-white dark:bg-stone-900 p-4 gap-3`}>
-					<View style={tw`flex-row items-center justify-between gap-3`}>
-						<SerifText style={tw`text-2xl`}>Personal radar</SerifText>
-						<MonospaceText style={tw`text-xs text-stone-500 dark:text-stone-400`}>
-							4 signals
-						</MonospaceText>
-					</View>
-					<View style={tw`gap-2.5`}>
-						<View style={tw`flex-row gap-2.5`}>
-							<View style={tw`mt-1.5 size-2 rounded-full bg-teal-500`} />
-							<SansSerifText
-								style={tw`flex-1 text-sm leading-5 text-stone-600 dark:text-stone-300`}
-							>
-								Package is likely to arrive before 2 PM.
-							</SansSerifText>
-						</View>
-						<View style={tw`flex-row gap-2.5`}>
-							<View style={tw`mt-1.5 size-2 rounded-full bg-amber-500`} />
-							<SansSerifText
-								style={tw`flex-1 text-sm leading-5 text-stone-600 dark:text-stone-300`}
-							>
-								Energy prices dip again after midnight.
-							</SansSerifText>
-						</View>
-						<View style={tw`flex-row gap-2.5`}>
-							<View style={tw`mt-1.5 size-2 rounded-full bg-sky-500`} />
-							<SansSerifText
-								style={tw`flex-1 text-sm leading-5 text-stone-600 dark:text-stone-300`}
-							>
-								A recipe you saved matches what is in the fridge.
-							</SansSerifText>
-						</View>
-					</View>
-				</FeedCard>
-
-				<Link href="/components" asChild>
-					<Pressable style={tw`self-start px-1 py-1`}>
-						<SansSerifText style={tw`text-sm text-teal-700 dark:text-teal-300`}>
-							View component library
-						</SansSerifText>
-					</Pressable>
-				</Link>
-			</ScrollView>
-
-			<ChatOverlay />
-		</View>
-	)
-}

apps/freya-client/src/app/_layout.tsx

@@ -3,12 +3,11 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 import { Stack } from "expo-router"
 import { StatusBar } from "expo-status-bar"
 import React from "react"
-import { useColorScheme, View } from "react-native"
+import { useColorScheme } from "react-native"
-import { KeyboardProvider } from "react-native-keyboard-controller"
 import tw, { useDeviceContext } from "twrnc"
 
+import { authMiddleware } from "@/api/auth-middleware"
 import { ApiClient, ApiClientContext } from "@/api/client"
-import { auth, authMiddleware } from "@/auth/auth"
 
 const queryClient = new QueryClient()
 const apiClient = new ApiClient({
@@ -23,12 +22,6 @@ export default function RootLayout() {
 	const headerBg = colorScheme === "dark" ? "#1c1917" : "#f5f5f4"
 	const headerTint = colorScheme === "dark" ? "#e7e5e4" : "#1c1917"
 
-	const { data: session, isPending: isLoadingSession } = auth.useSession()
-
-	if (isLoadingSession) {
-		return null
-	}
-
 	return (
 		<ContextProvider>
 			<Stack
@@ -37,34 +30,26 @@ export default function RootLayout() {
 					contentStyle: { backgroundColor: headerBg },
 				}}
 			>
-				<Stack.Protected guard={!session}>
+				<Stack.Screen
-					<Stack.Screen name="sign-in" />
+					name="components/index"
-				</Stack.Protected>
+					options={{
-
+						headerShown: true,
-				<Stack.Protected guard={Boolean(session)}>
+						title: "Components",
-					<Stack.Screen name="(app)" />
+						headerStyle: { backgroundColor: headerBg },
-
+						headerTintColor: headerTint,
-					<Stack.Screen
+						headerShadowVisible: false,
-						name="components/index"
+					}}
-						options={{
+				/>
-							headerShown: true,
+				<Stack.Screen
-							title: "Components",
+					name="components/[name]"
-							headerStyle: { backgroundColor: headerBg },
+					options={{
-							headerTintColor: headerTint,
+						headerShown: true,
-							headerShadowVisible: false,
+						title: "",
-						}}
+						headerStyle: { backgroundColor: headerBg },
-					/>
+						headerTintColor: headerTint,
-					<Stack.Screen
+						headerShadowVisible: false,
-						name="components/[name]"
+					}}
-						options={{
+				/>
-							headerShown: true,
-							title: "",
-							headerStyle: { backgroundColor: headerBg },
-							headerTintColor: headerTint,
-							headerShadowVisible: false,
-						}}
-					/>
-				</Stack.Protected>
 			</Stack>
 			<StatusBar style="auto" />
 		</ContextProvider>
@@ -73,10 +58,8 @@ export default function RootLayout() {
 
 function ContextProvider({ children }: React.PropsWithChildren) {
 	return (
-		<KeyboardProvider>
+		<QueryClientProvider client={queryClient}>
-			<QueryClientProvider client={queryClient}>
+			<ApiClientContext value={apiClient}>{children}</ApiClientContext>
-				<ApiClientContext value={apiClient}>{children}</ApiClientContext>
+		</QueryClientProvider>
-			</QueryClientProvider>
-		</KeyboardProvider>
 	)
 }

apps/freya-client/src/app/index.tsx

@@ -0,0 +1,28 @@
+import { Link } from "expo-router"
+import { Pressable } from "react-native"
+import { SafeAreaView } from "react-native-safe-area-context"
+import tw from "twrnc"
+
+import { Button } from "@/components/ui/button"
+import { FeedCard } from "@/components/ui/feed-card"
+import { MonospaceText } from "@/components/ui/monospace-text"
+import { SansSerifText } from "@/components/ui/sans-serif-text"
+import { SerifText } from "@/components/ui/serif-text"
+
+export default function HomeScreen() {
+	return (
+		<SafeAreaView style={tw`bg-stone-100 dark:bg-stone-900 flex-1 px-5 pt-6 gap-4`}>
+			<FeedCard>
+				<SerifText style={tw`text-4xl`}>Hello world asdsadsa</SerifText>
+				<SansSerifText style={tw`text-4xl font-bold`}>Hello world</SansSerifText>
+				<MonospaceText style={tw`text-4xl`}>asdjsakljdl</MonospaceText>
+				<Button style={tw`self-start`} label="Test" />
+			</FeedCard>
+			<Link href="/components" asChild>
+				<Pressable>
+					<SansSerifText style={tw`text-teal-600`}>View component library</SansSerifText>
+				</Pressable>
+			</Link>
+		</SafeAreaView>
+	)
+}

apps/freya-client/src/app/sign-in.tsx

@@ -1,221 +0,0 @@
-import { mutationOptions, useMutation } from "@tanstack/react-query"
-import { useRouter } from "expo-router"
-/* eslint-disable react-hooks/immutability */
-import { useCallback, useImperativeHandle, useRef } from "react"
-import { ActivityIndicator, Alert, View } from "react-native"
-import { KeyboardAvoidingView, useKeyboardHandler } from "react-native-keyboard-controller"
-import Animated, {
-	useAnimatedStyle,
-	useSharedValue,
-	withDelay,
-	withSpring,
-} from "react-native-reanimated"
-import { SafeAreaView, useSafeAreaInsets } from "react-native-safe-area-context"
-import tw from "twrnc"
-
-import { auth, signInMutation } from "@/auth/auth"
-import { InvalidCredentialsError, BetterAuthError } from "@/auth/error"
-import { Button } from "@/components/ui/button"
-import { SansSerifText } from "@/components/ui/sans-serif-text"
-import { SerifText } from "@/components/ui/serif-text"
-import { TextInput } from "@/components/ui/text-input"
-
-export default function SignInPage() {
-	console.log("sing in page ")
-	const loginFormRef = useRef<LoginFormContainerRef>(null)
-	const emailButtonHeight = useRef(0)
-
-	return (
-		<View style={tw`size-full relative`}>
-			<SafeAreaView
-				style={tw`flex-1 bg-stone-50 dark:bg-stone-900 justify-center items-start px-6`}
-			>
-				<View style={tw`flex-1 justify-center items-start`}>
-					<SerifText style={tw`text-lg mb-1.5`}>I&apos;m Freya!</SerifText>
-					<SerifText style={tw`text-lg opacity-70 leading-tight`}>
-						Before I can help you with your daily routines, please sign in below.
-					</SerifText>
-				</View>
-				<Button
-					onLayout={({ nativeEvent: { layout } }) => {
-						emailButtonHeight.current = layout.height
-					}}
-					intent="secondary"
-					style={tw`w-full`}
-					onPress={() => {
-						loginFormRef.current?.show({
-							fromHeight: emailButtonHeight.current,
-						})
-					}}
-				>
-					<Button.Label>Continue with email</Button.Label>
-				</Button>
-			</SafeAreaView>
-
-			<LoginFormContainer ref={loginFormRef}>
-				<LoginForm />
-			</LoginFormContainer>
-		</View>
-	)
-}
-
-interface LoginFormContainerRef {
-	show: ({ fromHeight }: { fromHeight: number }) => void
-}
-
-function LoginFormContainer({
-	ref,
-	children,
-}: React.PropsWithChildren<{ ref?: React.Ref<LoginFormContainerRef> }>) {
-	console.log("LoginFormContainer")
-	const safeAreaInsets = useSafeAreaInsets()
-
-	const opacity = useSharedValue(0)
-	const contentOpacity = useSharedValue(0)
-	const insetX = useSharedValue(0)
-	const bottom = useSharedValue(0)
-	const height = useSharedValue(0)
-	const finalHeight = useRef(0)
-
-	const show = useCallback(
-		({ fromHeight }: { fromHeight: number }) => {
-			insetX.value = 24
-			bottom.value = safeAreaInsets.bottom
-			height.value = fromHeight
-			opacity.value = 1
-
-			insetX.value = withSpring(0)
-			bottom.value = withSpring(0)
-			height.value = withSpring(finalHeight.current)
-			contentOpacity.value = withDelay(100, withSpring(1))
-		},
-		[opacity, insetX, bottom, safeAreaInsets.bottom, height, contentOpacity],
-	)
-
-	useImperativeHandle(ref, () => ({ show }))
-
-	useKeyboardHandler({
-		onMove: ({ progress, height, duration }) => {
-			"worklet"
-			bottom.value = height
-		},
-	})
-
-	const animatedStyle = useAnimatedStyle(() => ({
-		height: opacity.value !== 0 ? height.value : undefined,
-		opacity: opacity.value,
-		left: insetX.value,
-		right: insetX.value,
-		bottom: bottom.value,
-	}))
-
-	return (
-		<Animated.View
-			onLayout={({ nativeEvent: { layout } }) => {
-				finalHeight.current = layout.height
-			}}
-			style={[
-				tw`absolute overflow-hidden border border-stone-200 dark:border-stone-700 rounded-2xl`,
-				animatedStyle,
-			]}
-		>
-			<KeyboardAvoidingView behavior="padding">
-				<SafeAreaView
-					edges={["bottom"]}
-					style={tw`px-4 bg-stone-100 dark:bg-stone-800 overflow-hidden`}
-				>
-					<Animated.View style={[tw`w-full`, { opacity: contentOpacity }]}>
-						{children}
-					</Animated.View>
-				</SafeAreaView>
-			</KeyboardAvoidingView>
-		</Animated.View>
-	)
-}
-
-function LoginForm() {
-	console.log("LoginForm")
-	const emailRef = useRef("")
-	const passwordRef = useRef("")
-	const router = useRouter()
-
-	const { mutate: signIn, isPending: isSigningIn } = useMutation(
-		mutationOptions({
-			...signInMutation,
-			onSuccess: (data) => {
-				if (data) {
-					router.replace("/")
-				} else {
-					// if no data is returned, nothing was done, so do nothing
-				}
-			},
-			onError: (error) => {
-				console.log(error)
-				if (error instanceof InvalidCredentialsError) {
-					Alert.alert("Failed to sign in", "Incorrect email or password")
-				} else if (error instanceof BetterAuthError) {
-					Alert.alert(
-						"Failed to sign in",
-						"This is a fault on Freya's end. Please try again later.",
-					)
-				} else {
-					Alert.alert(
-						"Unable to connect to Freya",
-						"Please check your internet connection and try again.",
-					)
-				}
-			},
-		}),
-	)
-
-	const handleSignInButtonPress = () => {
-		signIn({
-			email: emailRef.current,
-			password: passwordRef.current,
-		})
-	}
-
-	return (
-		<View style={[tw`w-full py-4`]}>
-			<View style={tw`flex flex-row w-full`}>
-				<View>
-					<View style={tw`h-8 justify-center mr-4`}>
-						<SansSerifText>Email</SansSerifText>
-					</View>
-					<View style={tw`my-1 h-px w-full bg-stone-200 dark:bg-stone-700 rounded-l-full`} />
-					<View style={tw`h-8 justify-center mr-4`}>
-						<SansSerifText>Password</SansSerifText>
-					</View>
-				</View>
-				<View style={tw`flex-1`}>
-					<TextInput
-						defaultValue=""
-						autoCapitalize="none"
-						keyboardType="email-address"
-						style={tw`w-full h-8 font-medium`}
-						onChangeText={(text) => {
-							emailRef.current = text
-						}}
-					/>
-					<View style={tw`my-1 h-px w-full bg-stone-200 dark:bg-stone-700 rounded-r-full`} />
-					<TextInput
-						defaultValue=""
-						secureTextEntry
-						style={tw`w-full h-8 font-medium`}
-						onChangeText={(text) => {
-							passwordRef.current = text
-						}}
-					/>
-				</View>
-			</View>
-			<Button
-				intent="primary"
-				style={tw`w-full mt-6`}
-				onPress={handleSignInButtonPress}
-				enabled={!isSigningIn}
-			>
-				{isSigningIn ? <Button.Loading /> : <Button.Label>Sign in</Button.Label>}
-			</Button>
-		</View>
-	)
-}

apps/freya-client/src/auth/auth.ts

@@ -1,57 +0,0 @@
-import { expoClient } from "@better-auth/expo/client"
-import { mutationOptions } from "@tanstack/react-query"
-import { createAuthClient } from "better-auth/react"
-import * as SecureStore from "expo-secure-store"
-
-import type { ApiRequestMiddleware } from "../api/client"
-
-import { BetterAuthError, InvalidCredentialsError } from "./error"
-
-export const auth = createAuthClient({
-	baseURL: process.env.EXPO_PUBLIC_SERVER_URL,
-	plugins: [
-		expoClient({
-			scheme: "freya",
-			storagePrefix: "chat.freya",
-			storage: SecureStore,
-		}),
-	],
-})
-
-export const authMiddleware: ApiRequestMiddleware = (_url, init) => {
-	const cookie = auth.getCookie()
-	const headers = new Headers(init.headers)
-	if (cookie) {
-		headers.set("Cookie", cookie)
-	}
-	return {
-		...init,
-		credentials: "omit",
-		headers,
-	}
-}
-
-export const signInMutation = mutationOptions({
-	mutationFn: async ({ email, password }: { email: string; password: string }) => {
-		if (email && password) {
-			const result = await auth.signIn.email({
-				email,
-				password,
-			})
-			if (result.error?.code) {
-				switch (result.error.code) {
-					case "INVALID_EMAIL":
-						throw new InvalidCredentialsError("Invalid email")
-					case "INVALID_PASSWORD":
-						throw new InvalidCredentialsError("Invalid password")
-					case "INVALID_EMAIL_OR_PASSWORD":
-						throw new InvalidCredentialsError("Invalid email or password")
-					default:
-						throw new BetterAuthError(result.error)
-				}
-			}
-			return result
-		}
-		return null
-	},
-})

apps/freya-client/src/auth/error.ts

@@ -1,27 +0,0 @@
-import type { auth } from "./auth"
-
-export class InvalidCredentialsError extends Error {
-	constructor(cause: unknown) {
-		super(`Invalid credentials: ${cause}`)
-	}
-}
-
-export class BetterAuthError extends Error {
-	// the type is copied from the shape of result.error from authClient.signIn.email
-	constructor(error: {
-		code?: string | undefined
-		message?: string | undefined
-		status: number
-		statusText: string
-	}) {
-		super(`${error.message ?? "BetterAuthError"}: ${error.status} ${error.statusText}`)
-	}
-}
-
-type BetterAuthErrorTypes = Partial<Record<keyof typeof auth.$ERROR_CODES, string>>
-
-export const AuthErrorCode = {
-	INVALID_EMAIL: "INVALID_EMAIL",
-	INVALID_PASSWORD: "INVALID_PASSWORD",
-	INVALID_EMAIL_OR_PASSWORD: "INVALID_EMAIL_OR_PASSWORD",
-} satisfies BetterAuthErrorTypes

apps/freya-client/src/components/ui/button.showcase.tsx

@@ -8,28 +8,25 @@ function ButtonShowcase() {
 	return (
 		<View style={tw`gap-6`}>
 			<Section title="Default">
-				<Button style={tw`self-start`}>
+				<Button style={tw`self-start`} label="Press me" />
-					<Button.Label>Press me</Button.Label>
-				</Button>
 			</Section>
 			<Section title="Leading icon">
-				<Button style={tw`self-start`}>
+				<Button style={tw`self-start`} label="Add item" leadingIcon={<Button.Icon name="plus" />} />
-					<Button.Icon name="plus" />
-					<Button.Label>Add item</Button.Label>
-				</Button>
 			</Section>
 			<Section title="Trailing icon">
-				<Button style={tw`self-start`}>
+				<Button
-					<Button.Label>Next</Button.Label>
+					style={tw`self-start`}
-					<Button.Icon name="arrow-right" />
+					label="Next"
-				</Button>
+					trailingIcon={<Button.Icon name="arrow-right" />}
+				/>
 			</Section>
 			<Section title="Both icons">
-				<Button style={tw`self-start`}>
+				<Button
-					<Button.Icon name="download" />
+					style={tw`self-start`}
-					<Button.Label>Download</Button.Label>
+					label="Download"
-					<Button.Icon name="chevron-down" />
+					leadingIcon={<Button.Icon name="download" />}
-				</Button>
+					trailingIcon={<Button.Icon name="chevron-down" />}
+				/>
 			</Section>
 		</View>
 	)

apps/freya-client/src/components/ui/button.tsx

@@ -1,214 +1,48 @@
 import Feather from "@expo/vector-icons/Feather"
-import { createContext, useContext } from "react"
+import { type PressableProps, Pressable, type StyleProp, View, type ViewStyle } from "react-native"
-import {
-	type PressableProps,
-	Pressable,
-	type TextStyle,
-	useColorScheme,
-	ActivityIndicator,
-} from "react-native"
 import tw from "twrnc"
 
-import { rva, type RvaProps } from "@/lib/rva"
-
 import { SansSerifText } from "./sans-serif-text"
 
 type FeatherIconName = React.ComponentProps<typeof Feather>["name"]
 
-const button = rva(
-	tw.style("rounded-2xl px-4 py-3 w-fit flex-row items-center justify-center gap-1.5 h-10", {
-		borderCurve: "continuous",
-	}),
-	{
-		variants: {
-			intent: {
-				primary: tw`bg-teal-600`,
-				secondary: tw`bg-stone-100 dark:bg-stone-800`,
-			},
-			pressed: {
-				true: tw`translate-y-px`,
-				false: null,
-			},
-			enabled: {
-				true: null,
-				false: tw`opacity-50`,
-			},
-			dark: {
-				true: null,
-				false: null,
-			},
-		},
-		defaultVariants: {
-			intent: "primary",
-			pressed: false,
-			enabled: true,
-			dark: false,
-		},
-		compoundVariants: [
-			// primary variants
-			{
-				intent: "primary",
-				enabled: true,
-				pressed: false,
-				style: {
-					boxShadow:
-						"inset 0 1px 0 0 #2dd4bf66, inset 0 -1px 0 0 #0f766eb3, 0 2px 4px 0 #0000001a, 0 0 0 1px #0f766e",
-				},
-			},
-			{
-				intent: "primary",
-				enabled: true,
-				pressed: true,
-				style: tw.style("bg-teal-700", {
-					boxShadow:
-						"inset 0 1px 2px 0 #042f2e80, inset 0 0 0 1px #0f766e, inset 0 -1px 0 0 #2dd4bf26",
-				}),
-			},
-
-			// secondary variants
-			{
-				intent: "secondary",
-				dark: false,
-				enabled: true,
-				pressed: false,
-				style: {
-					boxShadow: "inset 0 1px 0 0 #fdfdfd, 0 2px 4px 0 #0000001a, 0 0 0 1px #00000029",
-				},
-			},
-			{
-				intent: "secondary",
-				dark: false,
-				enabled: true,
-				pressed: true,
-				style: tw.style("bg-stone-200", {
-					boxShadow:
-						"inset 0 1px 2px 0 #0000001f, inset 0 0 0 1px #00000012, inset 0 -1px 0 0 #ffffff80",
-				}),
-			},
-
-			{
-				intent: "secondary",
-				dark: true,
-				enabled: true,
-				pressed: false,
-				style: tw.style("bg-stone-800", {
-					boxShadow:
-						"inset 0 1px 0 0 #4b4951, inset 0 -1px 0 0 #313036, 0 2px 4px 0 #0000001a, 0 0 0 1px #0d0d0d",
-				}),
-			},
-			{
-				intent: "secondary",
-				dark: true,
-				enabled: true,
-				pressed: true,
-				style: tw.style("bg-stone-900", {
-					boxShadow:
-						"inset 0 1px 2px 0 #00000080, inset 0 0 0 1px #00000066, inset 0 -1px 0 0 #ffffff0a",
-				}),
-			},
-		],
-	},
-)
-
-const label = rva<TextStyle>(
-	{},
-	{
-		variants: {
-			intent: {
-				primary: tw`text-stone-100 dark:text-stone-200 font-medium`,
-				secondary: tw`text-stone-800 dark:text-stone-200 font-medium`,
-			},
-		},
-	},
-)
-
-type ButtonVariants = Omit<RvaProps<typeof button>, "dark" | "pressed">
-type ButtonProps = PressableProps & ButtonVariants
-
-interface ButtonContext extends ButtonVariants {}
-
-const Context = createContext<ButtonContext>({})
-
-export function Button({ style, intent = "primary", enabled = true, ...props }: ButtonProps) {
-	const theme = useColorScheme()
-
-	return (
-		<Context value={{ enabled, intent }}>
-			<Pressable
-				style={(state) => [
-					button({
-						intent,
-						enabled,
-						pressed: state.pressed,
-						dark: theme === "dark",
-					}),
-					typeof style === "function" ? style(state) : style,
-				]}
-				{...props}
-			/>
-		</Context>
-	)
-}
-
 type ButtonIconProps = {
 	name: FeatherIconName
 }
 
 function ButtonIcon({ name }: ButtonIconProps) {
-	const context = useContext(Context)
+	return <Feather name={name} size={18} color={tw.color("text-stone-100 dark:text-stone-200")} />
-
-	let color: string
-	switch (context.intent) {
-		case "primary":
-			color = tw.color("text-stone-100 dark:text-stone-200") ?? ""
-			break
-		case "secondary":
-			color = tw.color("text-stone-800 dark:text-stone-200") ?? ""
-			break
-		default:
-			color = ""
-			break
-	}
-
-	return <Feather name={name} size={18} color={color} />
 }
 
-type ButtonLabelProps = React.ComponentProps<typeof SansSerifText>
+type ButtonProps = Omit<PressableProps, "children" | "style"> & {
+	label: string
+	leadingIcon?: React.ReactNode
+	style?: StyleProp<ViewStyle>
+	trailingIcon?: React.ReactNode
+}
+
+export function Button({ style, label, leadingIcon, trailingIcon, ...props }: ButtonProps) {
+	const hasIcons = leadingIcon != null || trailingIcon != null
+
+	const textElement = (
+		<SansSerifText style={tw`text-stone-100 dark:text-stone-200 font-medium`}>
+			{label}
+		</SansSerifText>
+	)
 
-function ButtonLabel({ style, ...props }: ButtonLabelProps) {
-	const context = useContext(Context)
 	return (
-		<SansSerifText
+		<Pressable style={[tw`rounded-full bg-teal-600 px-4 py-3 w-fit`, style]} {...props}>
-			style={[
+			{hasIcons ? (
-				label({
+				<View style={tw`flex-row items-center gap-1.5`}>
-					intent: context.intent,
+					{leadingIcon}
-				}),
+					{textElement}
-				style,
+					{trailingIcon}
-			]}
+				</View>
-			{...props}
+			) : (
-		/>
+				textElement
+			)}
+		</Pressable>
 	)
 }
 
-function ButtonLoadingIndicator() {
-	const context = useContext(Context)
-
-	let color: string
-	switch (context.intent) {
-		case "primary":
-			color = tw.color("text-stone-100 dark:text-stone-200") ?? ""
-			break
-		case "secondary":
-			color = tw.color("text-stone-800 dark:text-stone-200") ?? ""
-			break
-		default:
-			color = ""
-			break
-	}
-
-	return <ActivityIndicator color={color} />
-}
-
 Button.Icon = ButtonIcon
-Button.Label = ButtonLabel
-Button.Loading = ButtonLoadingIndicator

apps/freya-client/src/components/ui/feed-card.showcase.tsx

@@ -19,9 +19,7 @@ function FeedCardShowcase() {
 				<FeedCard style={tw`p-4 gap-2`}>
 					<SerifText style={tw`text-xl`}>Title</SerifText>
 					<SansSerifText>Body text inside a feed card.</SansSerifText>
-					<Button style={tw`self-start mt-2`}>
+					<Button style={tw`self-start mt-2`} label="Action" />
-						<Button.Label>Action</Button.Label>
-					</Button>
 				</FeedCard>
 			</Section>
 		</View>

apps/freya-client/src/components/ui/text-input.tsx

@@ -1,6 +0,0 @@
-import { TextInput as NativeTextInput, type TextInputProps } from "react-native"
-import tw from "twrnc"
-
-export function TextInput({ style, ...props }: TextInputProps) {
-	return <NativeTextInput style={[tw`text-stone-800 dark:text-stone-200`, style]} {...props} />
-}

apps/freya-client/src/conversations/chat-overlay.tsx

@@ -1,284 +0,0 @@
-/* eslint-disable react-hooks/immutability */
-import MaskedView from "@react-native-masked-view/masked-view"
-import { BlurView } from "expo-blur"
-import { LinearGradient } from "expo-linear-gradient"
-import { atom, useAtomValue, useSetAtom, useStore } from "jotai"
-import { useCallback, useEffect, useImperativeHandle, useMemo, useRef } from "react"
-import { useColorScheme, View, StyleSheet, Platform, Dimensions } from "react-native"
-import { easeGradient } from "react-native-easing-gradient"
-import { useKeyboardHandler } from "react-native-keyboard-controller"
-import Animated, { FadeIn, FadeOut, useSharedValue, withSpring } from "react-native-reanimated"
-import { useSafeAreaInsets } from "react-native-safe-area-context"
-import tw from "twrnc"
-
-import { Button } from "@/components/ui/button"
-import { TextInput } from "@/components/ui/text-input"
-
-import { ConversationList } from "./conversation-list"
-
-interface BottomProgressiveBlurRef {
-	setBlurHeight: (height: number) => void
-}
-
-interface ConversationListContainerRef {
-	showFullChat: () => void
-}
-
-const ChatViewMode = {
-	Hidden: "hidden",
-	Peek: "peek",
-	FullChat: "full-chat",
-} as const
-type ChatViewMode = (typeof ChatViewMode)[keyof typeof ChatViewMode]
-
-const chatInputHeightAtom = atom(0)
-const isChatInputFocusedAtom = atom(false)
-const chatViewModeAtom = atom<ChatViewMode>(ChatViewMode.Hidden)
-
-export function ChatOverlay() {
-	const theme = useColorScheme()
-	const setChatInputHeight = useSetAtom(chatInputHeightAtom)
-	const setIsChatInputFocused = useSetAtom(isChatInputFocusedAtom)
-	const setChatViewMode = useSetAtom(chatViewModeAtom)
-	const store = useStore()
-
-	const conversationListContainerRef = useRef<ConversationListContainerRef>(null)
-
-	const onTextInputFocus = () => {
-		setChatViewMode(ChatViewMode.Peek)
-	}
-
-	const onConversationListScroll = () => {
-		if (store.get(chatViewModeAtom) !== ChatViewMode.FullChat) {
-			setChatViewMode(ChatViewMode.FullChat)
-			conversationListContainerRef?.current?.showFullChat()
-		}
-	}
-
-	return (
-		<ChatOverlayContainer>
-			<OverlayBackdrop />
-
-			<ConversationListContainer ref={conversationListContainerRef}>
-				<ConversationList
-					ListHeaderComponent={ConversationListHeader}
-					ListFooterComponent={ConversationListFooter}
-					onScrollBeginDrag={onConversationListScroll}
-				/>
-			</ConversationListContainer>
-
-			<ChatInputContainer>
-				<BlurView
-					onLayout={({ nativeEvent: { layout } }) => {
-						setChatInputHeight(layout.height)
-					}}
-					intensity={35}
-					tint={theme === "dark" ? "systemThickMaterialDark" : "systemThickMaterialLight"}
-					style={tw`flex flex-row w-full py-1 pl-4 pr-1 border border-stone-300 dark:border-stone-700 rounded-full overflow-hidden`}
-				>
-					<TextInput
-						onFocus={onTextInputFocus}
-						onBlur={() => {
-							setIsChatInputFocused(false)
-						}}
-						style={tw`flex-1`}
-						placeholder="Message Freya..."
-					/>
-					<Button style={tw`size-8 p-0`}>
-						<Button.Icon name="arrow-up" />
-					</Button>
-				</BlurView>
-			</ChatInputContainer>
-		</ChatOverlayContainer>
-	)
-}
-
-function ChatOverlayContainer({ children }: React.PropsWithChildren) {
-	const bottom = useSharedValue(0)
-
-	useKeyboardHandler({
-		onMove: (event) => {
-			"worklet"
-			bottom.value = event.height
-		},
-	})
-
-	return (
-		<Animated.View pointerEvents="box-none" style={[tw`absolute top-0 left-0 right-0`, { bottom }]}>
-			{children}
-		</Animated.View>
-	)
-}
-
-function ConversationListContainer({
-	ref,
-	children,
-}: React.PropsWithChildren<{ ref?: React.Ref<ConversationListContainerRef> }>) {
-	const chatViewMode = useAtomValue(chatViewModeAtom)
-	const height = useSharedValue(Dimensions.get("window").height * 0.4)
-
-	const { colors, locations } = useMemo(
-		() =>
-			easeGradient({
-				colorStops: {
-					0: { color: "transparent" },
-					0.1: { color: "transparent" },
-					0.3: { color: tw.color("bg-stone-100 dark:bg-stone-950")! },
-					0.9: { color: tw.color("bg-stone-100 dark:bg-stone-950")! },
-					1: { color: tw.color("bg-stone-100 dark:bg-stone-950")! },
-				},
-			}),
-		[],
-	)
-
-	const showFullChat = useCallback(() => {
-		height.value = withSpring(Dimensions.get("window").height + 80)
-	}, [height])
-
-	useImperativeHandle(
-		ref,
-		() => ({
-			showFullChat,
-		}),
-		[showFullChat],
-	)
-
-	return (
-		<View pointerEvents="box-none" style={tw.style("absolute top-0 left-0 right-0 bottom-0")}>
-			<MaskedView
-				pointerEvents="box-none"
-				maskElement={
-					<Animated.View style={[tw`absolute bottom-0 right-0 left-0`, { height }]}>
-						<LinearGradient
-							locations={locations as any}
-							colors={colors as any}
-							style={tw`size-full`}
-						/>
-					</Animated.View>
-				}
-				style={tw`size-full`}
-			>
-				<View
-					style={tw.style("size-full", chatViewMode === ChatViewMode.Hidden ? "opacity-0" : "")}
-				>
-					{children}
-				</View>
-			</MaskedView>
-		</View>
-	)
-}
-
-function OverlayBackdrop() {
-	const chatViewMode = useAtomValue(chatViewModeAtom)
-	const bottomProgressiveBlurRef = useRef<BottomProgressiveBlurRef>(null)
-
-	useEffect(() => {
-		if (chatViewMode === ChatViewMode.Peek) {
-			bottomProgressiveBlurRef?.current?.setBlurHeight(Dimensions.get("window").height * 0.75)
-		}
-	}, [chatViewMode])
-
-	if (chatViewMode === ChatViewMode.FullChat) {
-		return <BlurBackground />
-	}
-	return <BottomProgressiveBlur ref={bottomProgressiveBlurRef} />
-}
-
-function BottomProgressiveBlur({ ref }: { ref?: React.Ref<BottomProgressiveBlurRef> }) {
-	const progressiveBlurHeight = useSharedValue(192)
-	const colorScheme = useColorScheme()
-
-	const { colors, locations } = useMemo(
-		() =>
-			easeGradient({
-				colorStops: {
-					0: { color: "transparent" },
-					0.7: { color: tw.color("bg-stone-100 dark:bg-stone-950")! },
-					1: { color: tw.color("bg-stone-100 dark:bg-stone-950")! },
-				},
-			}),
-		[],
-	)
-
-	const setBlurHeight = useCallback(
-		(height: number) => {
-			progressiveBlurHeight.value = withSpring(height)
-		},
-		[progressiveBlurHeight],
-	)
-
-	useImperativeHandle(ref, () => ({ setBlurHeight }), [setBlurHeight])
-
-	return (
-		<Animated.View
-			entering={FadeIn}
-			exiting={FadeOut}
-			style={[tw`absolute bottom-0 left-0 right-0`, { height: progressiveBlurHeight }]}
-		>
-			<MaskedView
-				maskElement={
-					<LinearGradient
-						locations={locations as any}
-						colors={colors as any}
-						style={tw`absolute top-0 bottom-0 left-0 right-0`}
-					/>
-				}
-				style={[StyleSheet.absoluteFill, tw`z-[1]`]}
-			>
-				<BlurView
-					intensity={65}
-					tint={Platform.select({
-						ios:
-							colorScheme === "dark"
-								? "systemUltraThinMaterialDark"
-								: "systemUltraThinMaterialLight",
-						android: "systemMaterialDark",
-					})}
-					style={StyleSheet.absoluteFill}
-				/>
-			</MaskedView>
-		</Animated.View>
-	)
-}
-
-function BlurBackground() {
-	const colorScheme = useColorScheme()
-	return (
-		<Animated.View entering={FadeIn} exiting={FadeOut} style={StyleSheet.absoluteFill}>
-			<BlurView
-				intensity={65}
-				tint={Platform.select({
-					ios:
-						colorScheme === "dark" ? "systemUltraThinMaterialDark" : "systemUltraThinMaterialLight",
-					android: "systemMaterialDark",
-				})}
-				style={StyleSheet.absoluteFill}
-			/>
-		</Animated.View>
-	)
-}
-
-function ChatInputContainer({ children }: React.PropsWithChildren) {
-	const keyboardHeight = useSharedValue(0)
-	const insets = useSafeAreaInsets()
-
-	useKeyboardHandler({
-		onMove: (event) => {
-			"worklet"
-			keyboardHeight.value = Math.max(event.height - insets.bottom + 8, 0)
-		},
-	})
-
-	return <View style={tw`absolute bottom-0 left-0 right-0 px-4 pb-10`}>{children}</View>
-}
-
-function ConversationListHeader() {
-	const safeAreaInsets = useSafeAreaInsets()
-	return <View style={{ height: safeAreaInsets.top }} />
-}
-
-function ConversationListFooter() {
-	const chatInputHeight = useAtomValue(chatInputHeightAtom)
-	const safeAreaInsets = useSafeAreaInsets()
-	return <View style={{ height: chatInputHeight + 24 + safeAreaInsets.bottom }} />
-}

apps/freya-client/src/conversations/conversation-list.tsx

@@ -1,183 +0,0 @@
-import { AssistantMessagePayload, UserMessagePayload } from "@freya/core"
-import { FlashList } from "@shopify/flash-list"
-import { useQuery } from "@tanstack/react-query"
-import { View, ViewStyle } from "react-native"
-import tw from "twrnc"
-
-import { SansSerifText } from "@/components/ui/sans-serif-text"
-
-import { ConversationEntry } from "./conversations"
-import { useListConversationEntriesQuery, useDefaultConversationQuery } from "./queries"
-
-type ConversationListProps = Omit<
-	React.ComponentProps<typeof FlashList>,
-	"data" | "keyExtractor" | "renderItem" | "maintainVisibleContentPosition"
->
-
-type PositionInGroup = "single" | "first" | "in-between" | "last"
-
-const messageBubbleRadius = 18
-const groupedMessageBubbleRadius = 6
-
-export function ConversationList({
-	ListFooterComponent,
-	ListHeaderComponent,
-	onScrollBeginDrag,
-}: ConversationListProps) {
-	const { data: conversation } = useQuery(useDefaultConversationQuery())
-	const { data: entries } = useQuery(useListConversationEntriesQuery(conversation?.id))
-	const conversationEntries = entries ?? []
-
-	return (
-		<FlashList
-			style={tw`size-full`}
-			maintainVisibleContentPosition={{ startRenderingFromBottom: true }}
-			data={conversationEntries}
-			keyExtractor={(item) => item.id}
-			renderItem={({ item, index }) => {
-				const previousEntryIsSameKind = conversationEntries[index - 1]?.kind === item.kind
-				const nextEntryIsSameKind = conversationEntries[index + 1]?.kind === item.kind
-
-				let position: PositionInGroup
-				if (!previousEntryIsSameKind && !nextEntryIsSameKind) {
-					position = "single"
-				} else if (!previousEntryIsSameKind) {
-					position = "first"
-				} else if (!nextEntryIsSameKind) {
-					position = "last"
-				} else {
-					position = "in-between"
-				}
-
-				return <MessageBubble entry={item} position={position} />
-			}}
-			onScrollBeginDrag={onScrollBeginDrag}
-			ListHeaderComponent={ListHeaderComponent}
-			ListFooterComponent={ListFooterComponent}
-		/>
-	)
-}
-
-function MessageBubble({
-	entry,
-	position,
-}: {
-	entry: typeof ConversationEntry.infer
-	position: PositionInGroup
-}) {
-	if (entry.kind === "user_message") {
-		const payload = UserMessagePayload.assert(entry.payload)
-		return <UserMessageBubble payload={payload} position={position} />
-	}
-	if (entry.kind === "assistant_message") {
-		const payload = AssistantMessagePayload.assert(entry.payload)
-		return <AssistantMessageBubble payload={payload} position={position} />
-	}
-	return null
-}
-
-function UserMessageBubble({
-	payload,
-	position,
-}: {
-	payload: UserMessagePayload
-	position: PositionInGroup
-}) {
-	const content = payload.parts.reduce((final, part) => {
-		if (part.type === "text") {
-			return final + part.text
-		}
-		return final
-	}, "")
-
-	let corners: ViewStyle
-	switch (position) {
-		case "single":
-		case "first":
-			corners = {
-				borderRadius: messageBubbleRadius,
-				borderBottomRightRadius: groupedMessageBubbleRadius,
-			}
-			break
-		case "in-between":
-			corners = {
-				borderRadius: messageBubbleRadius,
-				borderTopRightRadius: groupedMessageBubbleRadius,
-				borderBottomRightRadius: groupedMessageBubbleRadius,
-			}
-			break
-		case "last":
-			corners = {
-				borderRadius: messageBubbleRadius,
-				borderTopRightRadius: groupedMessageBubbleRadius,
-			}
-			break
-	}
-
-	return (
-		<View style={tw`w-full flex-row justify-end mb-4 pr-4`}>
-			<View
-				style={tw.style("bg-teal-600 px-3 py-2 overflow-hidden max-w-56", corners, {
-					borderCurve: "circular",
-				})}
-			>
-				<SansSerifText style={tw`text-stone-100`}>{content}</SansSerifText>
-			</View>
-		</View>
-	)
-}
-
-function AssistantMessageBubble({
-	payload,
-	position,
-}: {
-	payload: AssistantMessagePayload
-	position: PositionInGroup
-}) {
-	const content = payload.parts.reduce((final, part) => {
-		if (part.type === "text") {
-			return final + part.text
-		}
-		return final
-	}, "")
-
-	let corners: ViewStyle
-	switch (position) {
-		case "single":
-		case "first":
-			corners = {
-				borderRadius: messageBubbleRadius,
-				borderBottomLeftRadius: groupedMessageBubbleRadius,
-			}
-			break
-		case "in-between":
-			corners = {
-				borderRadius: messageBubbleRadius,
-				borderTopLeftRadius: groupedMessageBubbleRadius,
-				borderBottomLeftRadius: groupedMessageBubbleRadius,
-			}
-			break
-		case "last":
-			corners = {
-				borderRadius: messageBubbleRadius,
-				borderTopLeftRadius: groupedMessageBubbleRadius,
-			}
-			break
-	}
-
-	return (
-		<View style={tw`w-full flex-row justify-start mb-4 pl-4`}>
-			<View
-				style={tw.style(
-					"bg-stone-200 dark:bg-stone-800 border border-stone-300 dark:border-stone-700 px-3 py-2 overflow-hidden max-w-56",
-					corners,
-					{
-						borderCurve: "circular",
-					},
-				)}
-			>
-				<SansSerifText style={tw`text-stone-950 dark:text-stone-100`}>{content}</SansSerifText>
-			</View>
-		</View>
-	)
-}

apps/freya-client/src/conversations/conversations.ts

@@ -1,21 +0,0 @@
-import {
-	ConversationEntryKind,
-	ConversationEntryPayload,
-	ConversationEntryVisibility,
-} from "@freya/core"
-import { type } from "arktype"
-
-export const Conversation = type({
-	id: "string.uuid",
-	createdAt: "string.date.iso",
-	updatedAt: "string.date.iso",
-})
-
-export const ConversationEntry = type({
-	id: "string.uuid",
-	sequence: "number",
-	kind: type.enumerated(...Object.values(ConversationEntryKind)),
-	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
-	fileId: "string | null",
-	payload: ConversationEntryPayload,
-})

apps/freya-client/src/conversations/queries.ts

@@ -1,47 +0,0 @@
-import { queryOptions, skipToken } from "@tanstack/react-query"
-import { type } from "arktype"
-
-import { useApiClient } from "@/api/client"
-
-import { Conversation, ConversationEntry } from "./conversations"
-
-const ListConversationsResponse = type({
-	conversations: Conversation.array(),
-})
-
-const ConversationEntriesResponse = type({
-	entries: ConversationEntry.array(),
-})
-
-export function useListConversationsQuery() {
-	const api = useApiClient()
-	return queryOptions({
-		queryKey: ["conversations"],
-		queryFn: async () =>
-			api
-				.request("/conversations", { method: "GET" })
-				.then(([, json]) => ListConversationsResponse.assert(json)),
-	})
-}
-
-export function useDefaultConversationQuery() {
-	return queryOptions({
-		...useListConversationsQuery(),
-		select: (data) => {
-			return data.conversations.length === 0 ? null : data.conversations[0]
-		},
-	})
-}
-
-export function useListConversationEntriesQuery(id?: string) {
-	const api = useApiClient()
-	return queryOptions({
-		queryKey: ["conversations", id],
-		queryFn: id
-			? async () =>
-					api
-						.request(`/conversations/${id}/entries`, { method: "GET" })
-						.then(([, json]) => ConversationEntriesResponse.assert(json).entries)
-			: skipToken,
-	})
-}

apps/freya-client/src/json-render/catalog.ts

@@ -15,29 +15,15 @@ export const catalog = defineCatalog(schema, {
 		},
 		Button: {
 			props: z.object({
-				intent: z.enum(["primary", "secondary"]).nullable(),
+				label: z.string(),
+				leadingIcon: z.string().nullable(),
+				trailingIcon: z.string().nullable(),
 			}),
 			events: ["press"],
-			slots: ["default"],
+			slots: [],
 			description:
-				"Pressable button. Add ButtonLabel and optional ButtonIcon children in the default slot. Bind on.press to trigger an action.",
+				"Pressable button with a label and optional Feather icons. Icon values are Feather icon names (e.g. 'plus', 'arrow-right'). Bind on.press to trigger an action.",
-			example: { intent: "primary" },
+			example: { label: "Add item", leadingIcon: "plus", trailingIcon: null },
-		},
-		ButtonIcon: {
-			props: z.object({
-				name: z.string(),
-			}),
-			slots: [],
-			description: "Feather icon for use inside a Button.",
-			example: { name: "plus" },
-		},
-		ButtonLabel: {
-			props: z.object({
-				text: z.string(),
-			}),
-			slots: [],
-			description: "Text label for use inside a Button.",
-			example: { text: "Add item" },
 		},
 		FeedCard: {
 			props: z.object({

apps/freya-client/src/json-render/registry.tsx

@@ -17,13 +17,20 @@ export const { registry } = defineRegistry(catalog, {
 		View: ({ props, children }) => (
 			<View style={props.style ? tw`${props.style}` : undefined}>{children}</View>
 		),
-		Button: ({ props, children, emit }) => (
+		Button: ({ props, emit }) => (
-			<Button intent={props.intent ?? undefined} onPress={() => emit("press")}>
+			<Button
-				{children}
+				label={props.label}
-			</Button>
+				leadingIcon={
+					props.leadingIcon ? <Button.Icon name={props.leadingIcon as ButtonIconName} /> : undefined
+				}
+				trailingIcon={
+					props.trailingIcon ? (
+						<Button.Icon name={props.trailingIcon as ButtonIconName} />
+					) : undefined
+				}
+				onPress={() => emit("press")}
+			/>
 		),
-		ButtonIcon: ({ props }) => <Button.Icon name={props.name as ButtonIconName} />,
-		ButtonLabel: ({ props }) => <Button.Label>{props.text}</Button.Label>,
 		FeedCard: ({ props, children }) => (
 			<FeedCard style={props.style ? tw`${props.style}` : undefined}>{children}</FeedCard>
 		),

apps/freya-client/src/lib/rva.ts

@@ -1,215 +0,0 @@
-import type { StyleProp, ViewStyle } from "react-native"
-
-type RvaNoInfer<TValue> = [TValue][TValue extends unknown ? 0 : never]
-type VariantValue = string | number | boolean | null | undefined
-type VariantOptionKey<TOptions> = Extract<keyof TOptions, string>
-type BooleanVariantInput<TOptions> =
-	Extract<VariantOptionKey<TOptions>, "true" | "false"> extends never ? never : boolean
-type StringVariantInput<TOptions> = Exclude<VariantOptionKey<TOptions>, "true" | "false">
-type VariantInput<TOptions> =
-	| StringVariantInput<TOptions>
-	| BooleanVariantInput<TOptions>
-	| null
-	| undefined
-type CompoundCondition<TVariants extends RvaVariants<unknown>> = {
-	name: keyof TVariants
-	value: string
-}
-type NormalizedCompoundVariant<TStyle, TVariants extends RvaVariants<TStyle>> = {
-	conditions: CompoundCondition<TVariants>[]
-	style: StyleProp<TStyle>
-}
-
-export type RvaVariants<TStyle = unknown> = {
-	readonly [name: string]: {
-		readonly [value: string]: StyleProp<TStyle>
-	}
-}
-
-export type RvaVariantProps<TVariants extends RvaVariants<unknown>> = {
-	readonly [TName in keyof TVariants]?: VariantInput<TVariants[TName]>
-}
-type MutableRvaVariantProps<TVariants extends RvaVariants<unknown>> = {
-	-readonly [TName in keyof TVariants]?: VariantInput<TVariants[TName]>
-}
-
-export type RvaCompoundVariant<
-	TStyle,
-	TVariants extends RvaVariants<TStyle>,
-> = RvaVariantProps<TVariants> & {
-	readonly style: StyleProp<TStyle>
-}
-
-export type RvaConfig<TStyle, TVariants extends RvaVariants<TStyle>> = {
-	readonly variants?: TVariants
-	readonly defaultVariants?: RvaVariantProps<TVariants>
-	readonly compoundVariants?: readonly RvaCompoundVariant<TStyle, TVariants>[]
-}
-
-export type RvaResolver<TStyle, TVariants extends RvaVariants<TStyle>> = (
-	props?: RvaVariantProps<TVariants>,
-) => StyleProp<TStyle>
-
-export type RvaProps<TResolver> = TResolver extends (props?: infer TProps) => unknown
-	? NonNullable<TProps>
-	: never
-
-export function rva<TStyle = ViewStyle>(): <
-	const TVariants extends RvaVariants<TStyle> = RvaVariants<TStyle>,
->(
-	base: StyleProp<RvaNoInfer<TStyle>>,
-	config?: RvaConfig<RvaNoInfer<TStyle>, TVariants>,
-) => RvaResolver<TStyle, TVariants>
-export function rva<
-	TStyle = ViewStyle,
-	const TVariants extends RvaVariants<TStyle> = RvaVariants<TStyle>,
->(
-	base: StyleProp<RvaNoInfer<TStyle>>,
-	config?: RvaConfig<RvaNoInfer<TStyle>, TVariants>,
-): RvaResolver<TStyle, TVariants>
-export function rva<
-	TStyle = ViewStyle,
-	const TVariants extends RvaVariants<TStyle> = RvaVariants<TStyle>,
->(
-	base?: StyleProp<TStyle>,
-	config?: RvaConfig<TStyle, TVariants>,
-):
-	| RvaResolver<TStyle, TVariants>
-	| (<const TTypedVariants extends RvaVariants<TStyle> = RvaVariants<TStyle>>(
-			base: StyleProp<TStyle>,
-			config?: RvaConfig<TStyle, TTypedVariants>,
-	  ) => RvaResolver<TStyle, TTypedVariants>) {
-	if (base === undefined && config === undefined) {
-		return function createTypedRva<
-			const TTypedVariants extends RvaVariants<TStyle> = RvaVariants<TStyle>,
-		>(typedBase: StyleProp<TStyle>, typedConfig: RvaConfig<TStyle, TTypedVariants> = {}) {
-			return createRva(typedBase, typedConfig)
-		}
-	}
-
-	return createRva(base, config ?? {})
-}
-
-function createRva<TStyle, const TVariants extends RvaVariants<TStyle> = RvaVariants<TStyle>>(
-	base: StyleProp<TStyle>,
-	config: RvaConfig<TStyle, TVariants>,
-): RvaResolver<TStyle, TVariants> {
-	const compoundVariants = normalizeCompoundVariants(config.compoundVariants)
-
-	return function resolveRva(props: RvaVariantProps<TVariants> = {}) {
-		const merged = mergeVariantProps(config.defaultVariants, props)
-		const styles: StyleProp<TStyle>[] = [base]
-		const variants = config.variants
-
-		if (variants !== undefined) {
-			for (const name in variants) {
-				const value = normalizeVariantValue(merged[name])
-
-				if (value === undefined) {
-					continue
-				}
-
-				const style = variants[name]?.[value]
-
-				if (style !== undefined) {
-					styles.push(style)
-				}
-			}
-		}
-
-		for (const compound of compoundVariants) {
-			if (compoundMatches(compound, merged)) {
-				styles.push(compound.style)
-			}
-		}
-
-		return styles
-	}
-}
-
-function mergeVariantProps<TVariants extends RvaVariants<unknown>>(
-	defaultVariants: RvaVariantProps<TVariants> | undefined,
-	props: RvaVariantProps<TVariants>,
-): RvaVariantProps<TVariants> {
-	const merged: MutableRvaVariantProps<TVariants> = {}
-
-	if (defaultVariants !== undefined) {
-		for (const name of Object.keys(defaultVariants) as (keyof TVariants)[]) {
-			const value = defaultVariants[name]
-
-			if (value !== undefined) {
-				merged[name] = value
-			}
-		}
-	}
-
-	for (const name of Object.keys(props) as (keyof TVariants)[]) {
-		const value = props[name]
-
-		if (value !== undefined) {
-			merged[name] = value
-		}
-	}
-
-	return merged
-}
-
-function normalizeCompoundVariants<TStyle, TVariants extends RvaVariants<TStyle>>(
-	compoundVariants: readonly RvaCompoundVariant<TStyle, TVariants>[] | undefined,
-) {
-	const normalized: NormalizedCompoundVariant<TStyle, TVariants>[] = []
-
-	if (compoundVariants === undefined) {
-		return normalized
-	}
-
-	for (const compound of compoundVariants) {
-		const conditions: CompoundCondition<TVariants>[] = []
-
-		for (const name in compound) {
-			if (name === "style") {
-				continue
-			}
-
-			const variantName = name as keyof TVariants
-			const value = normalizeVariantValue(compound[variantName])
-
-			if (value !== undefined) {
-				conditions.push({ name: variantName, value })
-			}
-		}
-
-		normalized.push({ conditions, style: compound.style })
-	}
-
-	return normalized
-}
-
-function compoundMatches<TStyle, TVariants extends RvaVariants<TStyle>>(
-	compound: NormalizedCompoundVariant<TStyle, TVariants>,
-	props: RvaVariantProps<TVariants>,
-) {
-	for (const condition of compound.conditions) {
-		if (normalizeVariantValue(props[condition.name]) !== condition.value) {
-			return false
-		}
-	}
-
-	return true
-}
-
-function normalizeVariantValue(value: VariantValue) {
-	if (value === null || value === undefined) {
-		return undefined
-	}
-
-	if (value === true) {
-		return "true"
-	}
-
-	if (value === false) {
-		return "false"
-	}
-
-	return String(value)
-}

bun.lock

@@ -51,15 +51,13 @@
       "version": "0.0.0",
       "dependencies": {
         "@freya/agent-protocol": "workspace:*",
-        "@nym.sh/jrpc": "^0.1.0",
+        "@nym.sh/jrpc": "1.1.0",
       },
     },
     "apps/freya-backend": {
       "name": "@freya/backend",
       "version": "0.0.0",
       "dependencies": {
-        "@better-auth/core": "^1.6.20",
-        "@better-auth/expo": "^1.6.20",
         "@earendil-works/pi-coding-agent": "^0.79.1",
         "@freya/agent-protocol": "workspace:*",
         "@freya/core": "workspace:*",
@@ -71,10 +69,10 @@
         "@freya/source-tfl": "workspace:*",
         "@freya/source-weatherkit": "workspace:*",
         "@freya/source-web-search": "workspace:*",
-        "@nym.sh/jrpc": "^0.1.0",
+        "@nym.sh/jrpc": "1.1.0",
         "@openrouter/sdk": "^0.9.11",
         "arktype": "^2.1.29",
-        "better-auth": "^1.6.20",
+        "better-auth": "^1",
         "drizzle-orm": "^0.45.1",
         "hono": "^4",
         "lodash.merge": "^4.6.2",
@@ -89,45 +87,29 @@
       "name": "freya-client",
       "version": "1.0.0",
       "dependencies": {
-        "@better-auth/core": "^1.6.20",
-        "@better-auth/expo": "^1.6.20",
         "@expo-google-fonts/inter": "^0.4.2",
         "@expo-google-fonts/source-serif-4": "^0.4.1",
         "@expo/vector-icons": "^15.0.3",
-        "@freya/core": "workspace:*",
         "@json-render/react-native": "^0.13.0",
-        "@react-native-masked-view/masked-view": "0.3.2",
-        "@shopify/flash-list": "2.0.2",
         "@tanstack/react-query": "^5.90.21",
-        "arktype": "^2.2.1",
-        "better-auth": "^1.6.20",
-        "class-variance-authority": "^0.7.1",
         "expo": "^56.0.0",
-        "expo-blur": "~56.0.3",
         "expo-constants": "~56.0.18",
         "expo-dev-client": "~56.0.20",
         "expo-font": "~56.0.7",
-        "expo-glass-effect": "~0.1.10",
         "expo-haptics": "~56.0.3",
         "expo-image": "~56.0.11",
-        "expo-linear-gradient": "~56.0.4",
         "expo-linking": "~56.0.14",
         "expo-location": "~56.0.18",
-        "expo-network": "~56.0.5",
         "expo-router": "~56.2.11",
-        "expo-secure-store": "~56.0.4",
         "expo-splash-screen": "~56.0.10",
         "expo-status-bar": "~56.0.4",
         "expo-symbols": "~56.0.6",
         "expo-system-ui": "~56.0.5",
         "expo-web-browser": "~56.0.5",
-        "jotai": "^2.20.1",
         "react": "19.2.3",
         "react-dom": "19.2.3",
         "react-native": "0.85.3",
-        "react-native-easing-gradient": "^1.1.1",
         "react-native-gesture-handler": "~2.31.1",
-        "react-native-keyboard-controller": "1.21.6",
         "react-native-reanimated": "4.3.1",
         "react-native-safe-area-context": "~5.7.0",
         "react-native-screens": "4.25.2",
@@ -176,6 +158,9 @@
     "packages/freya-agent-protocol": {
       "name": "@freya/agent-protocol",
       "version": "0.0.0",
+      "dependencies": {
+        "@freya/core": "workspace:*",
+      },
     },
     "packages/freya-components": {
       "name": "@freya/components",
@@ -295,9 +280,6 @@
       },
     },
   },
-  "patchedDependencies": {
-    "@ark/schema@0.56.0": "patches/@ark%2Fschema@0.56.0.patch",
-  },
   "packages": {
     "@adobe/css-tools": ["@adobe/css-tools@4.5.0", "", {}, "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q=="],
 
@@ -503,25 +485,23 @@
 
     "@babel/types": ["@babel/types@7.29.0", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.28.5" } }, "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A=="],
 
-    "@better-auth/core": ["@better-auth/core@1.6.20", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.39.0", "@standard-schema/spec": "^1.1.0", "zod": "^4.3.6" }, "peerDependencies": { "@better-auth/utils": "0.4.2", "@better-fetch/fetch": "1.3.1", "@cloudflare/workers-types": ">=4", "@opentelemetry/api": "^1.9.0", "better-call": "1.3.6", "jose": "^6.1.0", "kysely": "^0.28.5 || ^0.29.0", "nanostores": "^1.0.1" }, "optionalPeers": ["@cloudflare/workers-types", "@opentelemetry/api"] }, "sha512-y73I1xNXuNYiHBFduWGRcJ2ro2rNuVDEYkgVMJtIaRXtbosdXHs9gfyQrHecgeHMHKx1SYSBT/CExak0vVMTng=="],
+    "@better-auth/core": ["@better-auth/core@1.5.4", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "zod": "^4.3.6" }, "peerDependencies": { "@better-auth/utils": "0.3.1", "@better-fetch/fetch": "1.1.21", "@cloudflare/workers-types": ">=4", "better-call": "1.3.2", "jose": "^6.1.0", "kysely": "^0.28.5", "nanostores": "^1.0.1" }, "optionalPeers": ["@cloudflare/workers-types"] }, "sha512-k5AdwPRQETZn0vdB60EB9CDxxfllpJXKqVxTjyXIUSRz7delNGlU0cR/iRP3VfVJwvYR1NbekphBDNo+KGoEzQ=="],
 
-    "@better-auth/drizzle-adapter": ["@better-auth/drizzle-adapter@1.6.20", "", { "peerDependencies": { "@better-auth/core": "^1.6.20", "@better-auth/utils": "0.4.2", "drizzle-orm": "^0.45.2" }, "optionalPeers": ["drizzle-orm"] }, "sha512-hJHfCdAiZrC7EmZAt3NAiGgcNo9Y5Qz3PLL+a9rODXaAJGCMvzUJniqef9wHuJBwU0SWW+2f4wXe8xQmaC/IKQ=="],
+    "@better-auth/drizzle-adapter": ["@better-auth/drizzle-adapter@1.5.4", "", { "peerDependencies": { "@better-auth/core": "1.5.4", "@better-auth/utils": "^0.3.0", "drizzle-orm": ">=0.41.0" } }, "sha512-4M4nMAWrDd3TmpV6dONkJjybBVKRZghe5Oj0NNyDEoXubxastQdO7Sb5B54I1rTx5yoMgsqaB+kbJnu/9UgjQg=="],
 
-    "@better-auth/expo": ["@better-auth/expo@1.6.20", "", { "dependencies": { "@better-fetch/fetch": "1.3.1", "better-call": "1.3.6", "zod": "^4.3.6" }, "peerDependencies": { "@better-auth/core": "^1.6.20", "better-auth": "^1.6.20", "expo-constants": ">=17.0.0", "expo-linking": ">=7.0.0", "expo-network": ">=8.0.7", "expo-web-browser": ">=14.0.0" }, "optionalPeers": ["expo-constants", "expo-linking", "expo-network", "expo-web-browser"] }, "sha512-ngpD3ov51mcADMGqxVYu74mZLrjef72hFEcgpRNtJWc7uznrDn43LgiFRyrZWG8NUp3HaIK21D64/CVFvlVaKQ=="],
+    "@better-auth/kysely-adapter": ["@better-auth/kysely-adapter@1.5.4", "", { "peerDependencies": { "@better-auth/core": "1.5.4", "@better-auth/utils": "^0.3.0", "kysely": "^0.27.0 || ^0.28.0" } }, "sha512-DPww7rIfz6Ed7dZlJSW9xMQ42VKaJLB5Cs+pPqd+UHKRyighKjf3VgvMIcAdFPc4olQ0qRHo3+ZJhFlBCxRhxA=="],
 
-    "@better-auth/kysely-adapter": ["@better-auth/kysely-adapter@1.6.20", "", { "peerDependencies": { "@better-auth/core": "^1.6.20", "@better-auth/utils": "0.4.2", "kysely": "^0.28.17 || ^0.29.0" }, "optionalPeers": ["kysely"] }, "sha512-Uvpmgbx5y8JqXroVanNzDdKzOl3HojoTz+/X6MR6zOUr25IzlYz660mjnu0rxKiIF55kD3CroqFsDzjNUw7ERw=="],
+    "@better-auth/memory-adapter": ["@better-auth/memory-adapter@1.5.4", "", { "peerDependencies": { "@better-auth/core": "1.5.4", "@better-auth/utils": "^0.3.0" } }, "sha512-iiWYut9rbQqiAsgRBtj6+nxanwjapxRgpIJbiS2o81h7b9iclE0AiDA0Foes590gdFQvskNauZcCpuF8ytxthg=="],
 
-    "@better-auth/memory-adapter": ["@better-auth/memory-adapter@1.6.20", "", { "peerDependencies": { "@better-auth/core": "^1.6.20", "@better-auth/utils": "0.4.2" } }, "sha512-J5Ni0LlFijbzXlwu2rFHaD8zEFocmajyzWkRnHsq8LhV/Dk4iWQwwnqzLrPoDQEj8roECAUF03hrIeMzqWRqJQ=="],
+    "@better-auth/mongo-adapter": ["@better-auth/mongo-adapter@1.5.4", "", { "peerDependencies": { "@better-auth/core": "1.5.4", "@better-auth/utils": "^0.3.0", "mongodb": "^6.0.0 || ^7.0.0" } }, "sha512-ArzJN5Obk6i6+vLK1HpPzLIcsjxZYXPPUvxVU8eyU5HyoUT2MlswWfPQ8UJAKPn0iq/T4PVp/wZcQMhWk1tuNA=="],
 
-    "@better-auth/mongo-adapter": ["@better-auth/mongo-adapter@1.6.20", "", { "peerDependencies": { "@better-auth/core": "^1.6.20", "@better-auth/utils": "0.4.2", "mongodb": "^6.0.0 || ^7.0.0" }, "optionalPeers": ["mongodb"] }, "sha512-ClDBJf6h4g85WJswxwQwxLaiyRU67Gmz/uaIf19tY1gqlLJDykSGjmqRNSBMG5rWABNzcNqbO4KG31rYUldbIw=="],
+    "@better-auth/prisma-adapter": ["@better-auth/prisma-adapter@1.5.4", "", { "peerDependencies": { "@better-auth/core": "1.5.4", "@better-auth/utils": "^0.3.0", "@prisma/client": "^5.0.0 || ^6.0.0 || ^7.0.0", "prisma": "^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-ZQTbcBopw/ezjjbNFsfR3CRp0QciC4tJCarAnB5G9fZtUYbDjfY0vZOxIRmU4kI3x755CXQpGqTrkwmXaMRa3w=="],
 
-    "@better-auth/prisma-adapter": ["@better-auth/prisma-adapter@1.6.20", "", { "peerDependencies": { "@better-auth/core": "^1.6.20", "@better-auth/utils": "0.4.2", "@prisma/client": "^5.0.0 || ^6.0.0 || ^7.0.0", "prisma": "^5.0.0 || ^6.0.0 || ^7.0.0" }, "optionalPeers": ["@prisma/client", "prisma"] }, "sha512-WhYdhSGuVSfu1peCSf2snmmVzfWjRaEvbSrsNCusiwGE9l94HlES4mjSPM48fed24hL7yg4j1dYK/yjEt87FpQ=="],
+    "@better-auth/telemetry": ["@better-auth/telemetry@1.5.4", "", { "dependencies": { "@better-auth/utils": "0.3.1", "@better-fetch/fetch": "1.1.21" }, "peerDependencies": { "@better-auth/core": "1.5.4" } }, "sha512-mGXTY7Ecxo7uvlMr6TFCBUvlH0NUMOeE9LKgPhG4HyhBN6VfCEg/DD9PG0Z2IatmMWQbckkt7ox5A0eBpG9m5w=="],
 
-    "@better-auth/telemetry": ["@better-auth/telemetry@1.6.20", "", { "peerDependencies": { "@better-auth/core": "^1.6.20", "@better-auth/utils": "0.4.2", "@better-fetch/fetch": "1.3.1" } }, "sha512-3BhbY3naQDERvdJvJ7fGszVY6rpsVfc6c9uyBVZlC1coVEF/rkM0rIcjtMVI1GUH7vWy1wjR6qF5vQnMun3XNQ=="],
+    "@better-auth/utils": ["@better-auth/utils@0.3.1", "", {}, "sha512-+CGp4UmZSUrHHnpHhLPYu6cV+wSUSvVbZbNykxhUDocpVNTo9uFFxw/NqJlh1iC4wQ9HKKWGCKuZ5wUgS0v6Kg=="],
 
-    "@better-auth/utils": ["@better-auth/utils@0.4.2", "", { "dependencies": { "@noble/hashes": "^2.0.1" } }, "sha512-AUxrvu+HaaODsUyzDxFgwd/8RZ1yZaYo42LXKSrU2oGgR38pS1ij8nqQKNgtTWoYGpNevNXtCfgTy6loHveW9A=="],
+    "@better-fetch/fetch": ["@better-fetch/fetch@1.1.21", "", {}, "sha512-/ImESw0sskqlVR94jB+5+Pxjf+xBwDZF/N5+y2/q4EqD7IARUTSpPfIo8uf39SYpCxyOCtbyYpUrZ3F/k0zT4A=="],
-
-    "@better-fetch/fetch": ["@better-fetch/fetch@1.3.1", "", {}, "sha512-ABkD1WhyfPZprKRQI3bhATjeiFuNWC9PXhfGWqL+sg/gKrM977oFrYkdb4msM3hgUGonr7KlOsOFT5TU2rht9g=="],
 
     "@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@10.5.0", "", { "dependencies": { "@chevrotain/gast": "10.5.0", "@chevrotain/types": "10.5.0", "lodash": "4.17.21" } }, "sha512-lhmC/FyqQ2o7pGK4Om+hzuDrm9rhFYIJ/AXoQBeongmn870Xeb0L6oGEiuR8nohFNL5sMaQEJWCxr1oIVIVXrw=="],
 
@@ -861,7 +841,7 @@
 
     "@nolyfill/is-core-module": ["@nolyfill/is-core-module@1.0.39", "", {}, "sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA=="],
 
-    "@nym.sh/jrpc": ["@nym.sh/jrpc@0.1.0", "", {}, "sha512-qH+vqKojPrX4RkW67U2R4J98uWHxZOwYxX2J5GLZcfm/yjklCcN5zTfDNLfgAa9jAoOFVscC3DFWhvdZOmN3fA=="],
+    "@nym.sh/jrpc": ["@nym.sh/jrpc@1.1.0", "", {}, "sha512-212SYMB37GdL8enaRTTqG/LNa5bJ7eYth6jfQfECuedQCuaju0bOMUzCN6hvY5KkrxdYuqVKmr2Uz+ZZTjPlaQ=="],
 
     "@nym.sh/jrx": ["@nym.sh/jrx@0.2.0", "", { "peerDependencies": { "@json-render/core": ">=0.10.0" } }, "sha512-jd7Z1Q6T21366MtSUnwCFiu6Yl1AdNc9s5m6HxeUg265P+0enZCiyyxOuHsFwvpUcSEs/2DVBsqfMptdca44lA=="],
 
@@ -873,8 +853,6 @@
 
     "@openrouter/sdk": ["@openrouter/sdk@0.9.11", "", { "dependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-BgFu6NcIJO4a9aVjr04y3kZ8pyM71j15I+bzfVAGEvxnj+KQNIkBYQGgwrG3D+aT1QpDKLki8btcQmpaxUas6A=="],
 
-    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.41.1", "", {}, "sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA=="],
-
     "@oxfmt/darwin-arm64": ["@oxfmt/darwin-arm64@0.24.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-aYXuGf/yq8nsyEcHindGhiz9I+GEqLkVq8CfPbd+6VE259CpPEH+CaGHEO1j6vIOmNr8KHRq+IAjeRO2uJpb8A=="],
 
     "@oxfmt/darwin-x64": ["@oxfmt/darwin-x64@0.24.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-vs3b8Bs53hbiNvcNeBilzE/+IhDTWKjSBB3v/ztr664nZk65j0xr+5IHMBNz3CFppmX7o/aBta2PxY+t+4KoPg=="],
@@ -1401,8 +1379,6 @@
 
     "@sec-ant/readable-stream": ["@sec-ant/readable-stream@0.4.1", "", {}, "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg=="],
 
-    "@shopify/flash-list": ["@shopify/flash-list@2.0.2", "", { "dependencies": { "tslib": "2.8.1" }, "peerDependencies": { "@babel/runtime": "*", "react": "*", "react-native": "*" } }, "sha512-zhlrhA9eiuEzja4wxVvotgXHtqd3qsYbXkQ3rsBfOgbFA9BVeErpDE/yEwtlIviRGEqpuFj/oU5owD6ByaNX+w=="],
-
     "@silvia-odwyer/photon-node": ["@silvia-odwyer/photon-node@0.3.4", "", {}, "sha512-bnly4BKB3KDTFxrUIcgCLbaeVVS8lrAkri1pEzskpmxu9MdfGQTy8b8EgcD83ywD3RPMsIulY8xJH5Awa+t9fA=="],
 
     "@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
@@ -1671,9 +1647,9 @@
 
     "aria-query": ["aria-query@5.3.2", "", {}, "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw=="],
 
-    "arkregex": ["arkregex@0.0.6", "", { "dependencies": { "@ark/util": "0.56.0" } }, "sha512-9mvuMKQuibfWhBrsNYhsKhNb6k9oEHoAJ/FvDiqe8h+E9Siwe0/cro1WVOGgpajXQ9ZHd24yCOf2k35Q/QqUQw=="],
+    "arkregex": ["arkregex@0.0.5", "", { "dependencies": { "@ark/util": "0.56.0" } }, "sha512-ncYjBdLlh5/QnVsAA8De16Tc9EqmYM7y/WU9j+236KcyYNUXogpz3sC4ATIZYzzLxwI+0sEOaQLEmLmRleaEXw=="],
 
-    "arktype": ["arktype@2.2.1", "", { "dependencies": { "@ark/schema": "0.56.0", "@ark/util": "0.56.0", "arkregex": "0.0.6" } }, "sha512-CWPJxNoSxrS+NYGB3ufwc/blFonESEW5vBQyYPVS0rf4STu8VWoAWfKJSl5vVVm56h4yxpwbODeYwy6XFKvojA=="],
+    "arktype": ["arktype@2.2.0", "", { "dependencies": { "@ark/schema": "0.56.0", "@ark/util": "0.56.0", "arkregex": "0.0.5" } }, "sha512-t54MZ7ti5BhOEvzEkgKnWvqj+UbDfWig+DHr5I34xatymPusKLS0lQpNJd8M6DzmIto2QGszHfNKoFIT8tMCZQ=="],
 
     "array-buffer-byte-length": ["array-buffer-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "is-array-buffer": "^3.0.5" } }, "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw=="],
 
@@ -1735,9 +1711,9 @@
 
     "basic-auth": ["basic-auth@2.0.1", "", { "dependencies": { "safe-buffer": "5.1.2" } }, "sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg=="],
 
-    "better-auth": ["better-auth@1.6.20", "", { "dependencies": { "@better-auth/core": "1.6.20", "@better-auth/drizzle-adapter": "1.6.20", "@better-auth/kysely-adapter": "1.6.20", "@better-auth/memory-adapter": "1.6.20", "@better-auth/mongo-adapter": "1.6.20", "@better-auth/prisma-adapter": "1.6.20", "@better-auth/telemetry": "1.6.20", "@better-auth/utils": "0.4.2", "@better-fetch/fetch": "1.3.1", "@noble/ciphers": "^2.1.1", "@noble/hashes": "^2.0.1", "better-call": "1.3.6", "defu": "^6.1.4", "jose": "^6.1.3", "kysely": "^0.28.17 || ^0.29.0", "nanostores": "^1.1.1", "zod": "^4.3.6" }, "peerDependencies": { "@lynx-js/react": "*", "@prisma/client": "^5.0.0 || ^6.0.0 || ^7.0.0", "@sveltejs/kit": "^2.0.0", "@tanstack/react-start": "^1.0.0", "@tanstack/solid-start": "^1.0.0", "better-sqlite3": "^12.0.0", "drizzle-kit": ">=0.31.4", "drizzle-orm": "^0.45.2", "mongodb": "^6.0.0 || ^7.0.0", "mysql2": "^3.0.0", "next": "^14.0.0 || ^15.0.0 || ^16.0.0", "pg": "^8.0.0", "prisma": "^5.0.0 || ^6.0.0 || ^7.0.0", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0", "solid-js": "^1.0.0", "svelte": "^4.0.0 || ^5.0.0", "vitest": "^2.0.0 || ^3.0.0 || ^4.0.0", "vue": "^3.0.0" }, "optionalPeers": ["@lynx-js/react", "@prisma/client", "@sveltejs/kit", "@tanstack/react-start", "@tanstack/solid-start", "better-sqlite3", "drizzle-kit", "drizzle-orm", "mongodb", "mysql2", "next", "pg", "prisma", "react", "react-dom", "solid-js", "svelte", "vitest", "vue"] }, "sha512-fSpGHGRKiGRiYVd3QTQtuVZ8oxpiSe/7ip0Rpvt/Sy8zQbEbVKUPMOhE0gLXg+FjqTUsIo7582hxUYxtEcqUpA=="],
+    "better-auth": ["better-auth@1.5.4", "", { "dependencies": { "@better-auth/core": "1.5.4", "@better-auth/drizzle-adapter": "1.5.4", "@better-auth/kysely-adapter": "1.5.4", "@better-auth/memory-adapter": "1.5.4", "@better-auth/mongo-adapter": "1.5.4", "@better-auth/prisma-adapter": "1.5.4", "@better-auth/telemetry": "1.5.4", "@better-auth/utils": "0.3.1", "@better-fetch/fetch": "1.1.21", "@noble/ciphers": "^2.1.1", "@noble/hashes": "^2.0.1", "better-call": "1.3.2", "defu": "^6.1.4", "jose": "^6.1.3", "kysely": "^0.28.11", "nanostores": "^1.1.1", "zod": "^4.3.6" }, "peerDependencies": { "@lynx-js/react": "*", "@prisma/client": "^5.0.0 || ^6.0.0 || ^7.0.0", "@sveltejs/kit": "^2.0.0", "@tanstack/react-start": "^1.0.0", "@tanstack/solid-start": "^1.0.0", "better-sqlite3": "^12.0.0", "drizzle-kit": ">=0.31.4", "drizzle-orm": ">=0.41.0", "mongodb": "^6.0.0 || ^7.0.0", "mysql2": "^3.0.0", "next": "^14.0.0 || ^15.0.0 || ^16.0.0", "pg": "^8.0.0", "prisma": "^5.0.0 || ^6.0.0 || ^7.0.0", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0", "solid-js": "^1.0.0", "svelte": "^4.0.0 || ^5.0.0", "vitest": "^2.0.0 || ^3.0.0 || ^4.0.0", "vue": "^3.0.0" }, "optionalPeers": ["@lynx-js/react", "@prisma/client", "@sveltejs/kit", "@tanstack/react-start", "@tanstack/solid-start", "better-sqlite3", "drizzle-kit", "drizzle-orm", "mongodb", "mysql2", "next", "pg", "prisma", "react", "react-dom", "solid-js", "svelte", "vitest", "vue"] }, "sha512-ReykcEKx6Kp9560jG1wtlDBnftA7L7xb3ZZdDWm5yGXKKe2pUf+oBjH0fqekrkRII0m4XBVQbQ0mOrFv+3FdYg=="],
 
-    "better-call": ["better-call@1.3.6", "", { "dependencies": { "@better-auth/utils": "^0.4.0", "@better-fetch/fetch": "^1.1.21", "rou3": "^0.7.12", "set-cookie-parser": "^3.0.1" }, "peerDependencies": { "zod": "^4.0.0" }, "optionalPeers": ["zod"] }, "sha512-no1jI+h6Bkxs1NVBo4rONbVIzsPjZ8IUu7IHaJBiFwVX1XEQGN8KpHots5fSWmXe9nNyLuLIcgx6WEUcE6EDaA=="],
+    "better-call": ["better-call@1.3.2", "", { "dependencies": { "@better-auth/utils": "^0.3.1", "@better-fetch/fetch": "^1.1.21", "rou3": "^0.7.12", "set-cookie-parser": "^3.0.1" }, "peerDependencies": { "zod": "^4.0.0" }, "optionalPeers": ["zod"] }, "sha512-4cZIfrerDsNTn3cm+MhLbUePN0gdwkhSXEuG7r/zuQ8c/H7iU0/jSK5TD3FW7U0MgKHce/8jGpPYNO4Ve+4NBw=="],
 
     "big-integer": ["big-integer@1.6.52", "", {}, "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg=="],
 
@@ -2083,8 +2059,6 @@
 
     "expo-asset": ["expo-asset@56.0.17", "", { "dependencies": { "@expo/image-utils": "^0.10.1", "expo-constants": "~56.0.18" }, "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-GFN5j+8SPkyv0nfsiFHewmdB/D0tL237TsBE/gSfFOFy/J3a52py7IulcSqkA3sQE/u/UlD5BmvP5ssS4//nUg=="],
 
-    "expo-blur": ["expo-blur@56.0.3", "", { "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-KDDtrpWc2tYlm1WCPaOgBtv+YEGqe5ELheFPIgSNgHt28NQUDcfBcFsA9Us2StDh6osmSD6NbKxOt5bU6PcDbQ=="],
-
     "expo-constants": ["expo-constants@56.0.18", "", { "dependencies": { "@expo/env": "~2.3.0" }, "peerDependencies": { "expo": "*", "react-native": "*" } }, "sha512-8AMtbDGl/WVPnWlmbpGmvcdnNCy9E4PFnwdVwj600vljkMDPSxcAcjw8GVXEPk3PpZ+ngTqsrkltWyj0UKYAxw=="],
 
     "expo-dev-client": ["expo-dev-client@56.0.20", "", { "dependencies": { "expo-dev-launcher": "~56.0.20", "expo-dev-menu": "~56.0.17", "expo-dev-menu-interface": "~56.0.0", "expo-manifests": "~56.0.4", "expo-updates-interface": "~56.0.1" }, "peerDependencies": { "expo": "*" } }, "sha512-KebW4r8HhIiRrPzs6ZqVhp/so8buyglAO1h4No0Ibr5C2XRnlIoGWCN4zC6rW7IsI3iKUXcofLAQV9OjoxjiwQ=="],
@@ -2099,7 +2073,7 @@
 
     "expo-font": ["expo-font@56.0.7", "", { "dependencies": { "fontfaceobserver": "^2.1.0" }, "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-hpU/vRwPzsby9lPGkA4blDqLIIXYzoWnCZHr6PxvcWbY/uPObAiyhh6q+e0WYsB65SthK+PLH95jEnVag7fwEg=="],
 
-    "expo-glass-effect": ["expo-glass-effect@0.1.10", "", { "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-R0OrsMbs2TxFQZp26rRDl1Wxu5PaBXM7qAxiT0Bfyb1bojr3eI90bMKry9lBM3aKbq7DOBXYT7ePrE3vUaf41g=="],
+    "expo-glass-effect": ["expo-glass-effect@56.0.4", "", { "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-xI9rXtDwi7RW82uAlfyaXO6+k21ApWJ2tHAWYqPr/FjfmZbKsgNJ4Q0iZzGPCwboqjTGxaRZ61SZxBl8hDt5iA=="],
 
     "expo-haptics": ["expo-haptics@56.0.3", "", { "peerDependencies": { "expo": "*" } }, "sha512-ycoahZJnR9tWAVh/0mJYxbETtHRYaWjiWS8cHlP6aDGU6Q6Y8rZ5NKsuBwWw6HR2Pe30mfVFgbF2HrBR6gtYmw=="],
 
@@ -2109,8 +2083,6 @@
 
     "expo-keep-awake": ["expo-keep-awake@56.0.3", "", { "peerDependencies": { "expo": "*", "react": "*" } }, "sha512-CLMJXtEiMKknD3Rpm8CRwE6ZJUzu2yCEmRk1sgfHAJ1zIbuEWY3dpPDubtsnuzWm+2k6Sru+yaFbYsvPWmTiBA=="],
 
-    "expo-linear-gradient": ["expo-linear-gradient@56.0.4", "", { "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-KUp1dNSRtuMyiExhf6FJf5YUtmw2cRaPytl10HQi7isj5Yac38udmD55T2tglNYTZlvgT5+oflpyFoH15hmOcw=="],
-
     "expo-linking": ["expo-linking@56.0.14", "", { "dependencies": { "expo-constants": "~56.0.18", "invariant": "^2.2.4" }, "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-IvVQHWC+Cj4fK5qD3iEVYqpU2a4rLW0IpAAlGJ4MH+H1fyZiHh3eN6qg2WmoclOEPfYATSuEa+dQT6wfgVpXlQ=="],
 
     "expo-location": ["expo-location@56.0.18", "", { "dependencies": { "@expo/image-utils": "^0.10.1" }, "peerDependencies": { "expo": "*" } }, "sha512-6xP0UwGy8a7EEHAMeigYAp3HNo3yWHAg05tVPUfwrOWepWPpFXmjsfUBUxQdkpfpjddJ9r+f4PplxZqKI0LtjA=="],
@@ -2123,12 +2095,8 @@
 
     "expo-modules-jsi": ["expo-modules-jsi@56.0.10", "", { "peerDependencies": { "react-native": "*" } }, "sha512-fHZcFpYO/o62GYa6fJyAQJZcAShzhoN0iMMDzbr7vD3ewET6e1vAlTonbEakN9F0VHEgBFJ4NREy87uwVcpCuA=="],
 
-    "expo-network": ["expo-network@56.0.5", "", { "peerDependencies": { "expo": "*", "react": "*" } }, "sha512-zmuyO95jayDY9jyUfOAlNp9XXJrJaAOkBXXLy0TS/nh2kppj7CHirRPkQ/tf0rsxhIL3AEd9nsRTiPtNsGT9Lw=="],
-
     "expo-router": ["expo-router@56.2.11", "", { "dependencies": { "@expo/log-box": "^56.0.13", "@expo/metro-runtime": "^56.0.15", "@expo/schema-utils": "^56.0.0", "@expo/ui": "^56.0.18", "@radix-ui/react-slot": "^1.2.0", "@radix-ui/react-tabs": "^1.1.12", "@react-native-masked-view/masked-view": "^0.3.2", "@testing-library/jest-dom": "^6.9.1", "@testing-library/user-event": "^14.6.1", "client-only": "^0.0.1", "color": "^4.2.3", "debug": "^4.3.4", "escape-string-regexp": "^4.0.0", "expo-glass-effect": "^56.0.4", "expo-server": "^56.0.5", "expo-symbols": "^56.0.6", "fast-deep-equal": "^3.1.3", "invariant": "^2.2.4", "nanoid": "^3.3.8", "query-string": "^7.1.3", "react-fast-compare": "^3.2.2", "react-is": "^19.1.0", "react-native-drawer-layout": "^4.2.2", "react-native-screens": "^4.25.2", "server-only": "^0.0.1", "sf-symbols-typescript": "^2.1.0", "shallowequal": "^1.1.0", "standard-navigation": "^0.0.5", "vaul": "^1.1.2" }, "peerDependencies": { "@testing-library/react-native": ">= 13.2.0", "expo": "*", "expo-constants": "^56.0.18", "expo-linking": "^56.0.14", "react": "*", "react-dom": "*", "react-native": "*", "react-native-gesture-handler": "*", "react-native-reanimated": "*", "react-native-safe-area-context": ">= 5.4.0", "react-native-web": "*", "react-server-dom-webpack": "~19.0.4 || ~19.1.5 || ~19.2.4" }, "optionalPeers": ["@testing-library/react-native", "react-dom", "react-native-gesture-handler", "react-native-reanimated", "react-native-web", "react-server-dom-webpack"] }, "sha512-08DBTrKv3QanOc9u1JNxSEChW9c/qNFbQ0dO28OLvufWWfdSRkSdHmh365D2FgoZg1qaOzZPCDuL3tM6nGSfkQ=="],
 
-    "expo-secure-store": ["expo-secure-store@56.0.4", "", { "peerDependencies": { "expo": "*" } }, "sha512-hjEi/gmpdFFJ9lYbdp3k3p/WchV7Gi0Qt8jt/m/0WJadqQrskafHAlDxbZkII1cN3Yd7zp9Lvkeq3UfGhSwirQ=="],
-
     "expo-server": ["expo-server@56.0.5", "", {}, "sha512-SmM2p2g3Jrktpiazcst+OxhjSzOHXKAY4BPURHYHXvApzzoybMmrNF4IEZ8DKZ145BhSe4ydAmlEFCRTsdtgUQ=="],
 
     "expo-splash-screen": ["expo-splash-screen@56.0.10", "", { "dependencies": { "@expo/config-plugins": "~56.0.8", "@expo/image-utils": "^0.10.1", "xml2js": "0.6.0" }, "peerDependencies": { "expo": "*" } }, "sha512-vDIlo8hzt9HlCZQ0kSY66v83D1WEXOJbVMeyPDfXDu9tbDdPMNUyDpi4WGJXikAjxnAKfbt5Mv5NnEbxINy+VA=="],
@@ -2499,8 +2467,6 @@
 
     "jose": ["jose@6.2.1", "", {}, "sha512-jUaKr1yrbfaImV7R2TN/b3IcZzsw38/chqMpo2XJ7i2F8AfM/lA4G1goC3JVEwg0H7UldTmSt3P68nt31W7/mw=="],
 
-    "jotai": ["jotai@2.20.1", "", { "peerDependencies": { "@babel/core": ">=7.0.0", "@babel/template": ">=7.0.0", "@types/react": ">=17.0.0", "react": ">=17.0.0" }, "optionalPeers": ["@babel/core", "@babel/template", "@types/react", "react"] }, "sha512-dnuKfU/GLi8B28RRMjQ3AfoN7kfzP8o41+AX2FmITZqEMY8PHnjABq+VkEooomLwYaGjda+pgy0yFSjaHX/ZPg=="],
-
     "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
 
     "js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="],
@@ -2537,7 +2503,7 @@
 
     "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
 
-    "kysely": ["kysely@0.29.2", "", {}, "sha512-s6WVJyEZrbm6jhBpiKHsGHyePMrVQKJ85wZCFCr9W4QHv6WTjWIrdvTmO9hDEA3bNK0xkrE2DqrHsXMLWuZpQg=="],
+    "kysely": ["kysely@0.28.11", "", {}, "sha512-zpGIFg0HuoC893rIjYX1BETkVWdDnzTzF5e0kWXJFg5lE0k1/LfNWBejrcnOFu8Q2Rfq/hTDTU7XLUM8QOrpzg=="],
 
     "lan-network": ["lan-network@0.2.1", "", { "bin": { "lan-network": "dist/lan-network-cli.js" } }, "sha512-ONPnazC96VKDntab9j9JKwIWhZ4ZUceB4A9Epu4Ssg0hYFmtHZSeQ+n15nIwTFmcBUKtExOer8WTJ4GF9MO64A=="],
 
@@ -3053,14 +3019,10 @@
 
     "react-native-drawer-layout": ["react-native-drawer-layout@4.2.5", "", { "dependencies": { "color": "^4.2.3", "use-latest-callback": "^0.2.4" }, "peerDependencies": { "react": ">= 18.2.0", "react-native": "*", "react-native-gesture-handler": ">= 2.0.0", "react-native-reanimated": ">= 2.0.0" } }, "sha512-Yl82uLkXjXuq7222hWGIDsq5A6R/bsCeCEgdIxQUxAEHf00oRdDnRByLx3Fsij3qwtmYNPGrHV1NH8G8hbCbLQ=="],
 
-    "react-native-easing-gradient": ["react-native-easing-gradient@1.1.1", "", { "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-KrGU97kPTMrLNzVXxFirFMgl65uo70gVNoKw2OngDzcDfoswb648I3ggeCnoY+JgMWkPyx4LlG7n3ZNgSPFnLw=="],
-
     "react-native-gesture-handler": ["react-native-gesture-handler@2.31.2", "", { "dependencies": { "@egjs/hammerjs": "^2.0.17", "@types/react-test-renderer": "^19.1.0", "hoist-non-react-statics": "^3.3.0", "invariant": "^2.2.4" }, "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-rw5q74i2AfS7YGYdbxQDhOU7xqgY6WRM1132/CCm3erqjblhECZDZFHIm0tteHoC9ih24wogVBVVzcTBQtZ+5A=="],
 
     "react-native-is-edge-to-edge": ["react-native-is-edge-to-edge@1.3.1", "", { "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-NIXU/iT5+ORyCc7p0z2nnlkouYKX425vuU1OEm6bMMtWWR9yvb+Xg5AZmImTKoF9abxCPqrKC3rOZsKzUYgYZA=="],
 
-    "react-native-keyboard-controller": ["react-native-keyboard-controller@1.21.6", "", { "dependencies": { "react-native-is-edge-to-edge": "^1.2.1" }, "peerDependencies": { "react": "*", "react-native": "*", "react-native-reanimated": ">=3.0.0" } }, "sha512-nAXCmar/W8Gn4iQV7O5fAVuTh57JszCsqTS+cfR95WFOLR/AfbwfPz/+sWyz/q2SOIe2VpyQzq6hzYiwErhqqw=="],
-
     "react-native-reanimated": ["react-native-reanimated@4.3.1", "", { "dependencies": { "react-native-is-edge-to-edge": "^1.3.1", "semver": "^7.7.3" }, "peerDependencies": { "react": "*", "react-native": "0.81 - 0.85", "react-native-worklets": "0.8.x" } }, "sha512-KhGsS0YkCA+gusgyzlf9hnqzVPIR398KTpqXyqq/+yYJJPAvyEEPKcxlB0xtOOXSMrR2A9uRKVARVQhZwrOh+Q=="],
 
     "react-native-safe-area-context": ["react-native-safe-area-context@5.7.0", "", { "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-/9/MtQz8ODphjsLdZ+GZAIcC/RtoqW9EeShf7Uvnfgm/pzYrJ75y3PV/J1wuAV1T5Dye5ygq4EAW20RoBq0ABQ=="],
@@ -3383,7 +3345,7 @@
 
     "tsdav": ["tsdav@2.1.8", "", { "dependencies": { "base-64": "1.0.0", "cross-fetch": "4.1.0", "debug": "4.4.3", "xml-js": "1.6.11" } }, "sha512-zvQvhZLzTaEmNNgJbBlUYT/JOq9Xpw/xkxCqs7IT2d2/7o7pss0iZOlZXuHJ5VcvSvTny42Vc6+6GyzZcrCJ1g=="],
 
-    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+    "tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
 
     "tw-animate-css": ["tw-animate-css@1.4.0", "", {}, "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ=="],
 
@@ -3563,12 +3525,60 @@
 
     "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
 
+    "@aws-crypto/crc32/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-crypto/sha256-browser/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-crypto/sha256-js/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-crypto/supports-web-crypto/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-crypto/util/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/client-bedrock-runtime/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/core/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/credential-provider-env/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "@aws-sdk/credential-provider-http/@smithy/node-http-handler": ["@smithy/node-http-handler@4.7.8", "", { "dependencies": { "@smithy/core": "^3.24.7", "@smithy/types": "^4.14.4", "tslib": "^2.6.2" } }, "sha512-f+DbsWUwSbtMu1a/j8Y93KiU1SRg9nyzfjereqn1BJ33QOTUXxdlYvVXMhAYl1vuR1Kmna5aIJe09KSIfyFNYw=="],
 
+    "@aws-sdk/credential-provider-http/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/credential-provider-ini/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/credential-provider-login/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/credential-provider-node/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/credential-provider-process/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "@aws-sdk/credential-provider-sso/@aws-sdk/token-providers": ["@aws-sdk/token-providers@3.1066.0", "", { "dependencies": { "@aws-sdk/core": "^3.974.20", "@aws-sdk/nested-clients": "^3.997.20", "@aws-sdk/types": "^3.973.12", "@smithy/core": "^3.24.6", "@smithy/types": "^4.14.3", "tslib": "^2.6.2" } }, "sha512-UqEUJq7dqa44hneLDUcX7UJy95cg8YqEWyakRpvIPnrNS3Mq+UlQHgCDGu5pvwAPtlIW4qcYbvW6reG6++FyvA=="],
 
+    "@aws-sdk/credential-provider-sso/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/credential-provider-web-identity/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/eventstream-handler-node/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/middleware-eventstream/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/middleware-websocket/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "@aws-sdk/nested-clients/@smithy/node-http-handler": ["@smithy/node-http-handler@4.7.8", "", { "dependencies": { "@smithy/core": "^3.24.7", "@smithy/types": "^4.14.4", "tslib": "^2.6.2" } }, "sha512-f+DbsWUwSbtMu1a/j8Y93KiU1SRg9nyzfjereqn1BJ33QOTUXxdlYvVXMhAYl1vuR1Kmna5aIJe09KSIfyFNYw=="],
 
+    "@aws-sdk/nested-clients/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/signature-v4-multi-region/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/token-providers/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/types/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/util-locate-window/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-sdk/xml-builder/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "@babel/core/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
     "@babel/generator/jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
@@ -3609,12 +3619,6 @@
 
     "@ecies/ciphers/@noble/ciphers": ["@noble/ciphers@1.3.0", "", {}, "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw=="],
 
-    "@emnapi/core/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
-    "@emnapi/runtime/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
-    "@emnapi/wasi-threads/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
     "@esbuild-kit/core-utils/esbuild": ["esbuild@0.18.20", "", { "optionalDependencies": { "@esbuild/android-arm": "0.18.20", "@esbuild/android-arm64": "0.18.20", "@esbuild/android-x64": "0.18.20", "@esbuild/darwin-arm64": "0.18.20", "@esbuild/darwin-x64": "0.18.20", "@esbuild/freebsd-arm64": "0.18.20", "@esbuild/freebsd-x64": "0.18.20", "@esbuild/linux-arm": "0.18.20", "@esbuild/linux-arm64": "0.18.20", "@esbuild/linux-ia32": "0.18.20", "@esbuild/linux-loong64": "0.18.20", "@esbuild/linux-mips64el": "0.18.20", "@esbuild/linux-ppc64": "0.18.20", "@esbuild/linux-riscv64": "0.18.20", "@esbuild/linux-s390x": "0.18.20", "@esbuild/linux-x64": "0.18.20", "@esbuild/netbsd-x64": "0.18.20", "@esbuild/openbsd-x64": "0.18.20", "@esbuild/sunos-x64": "0.18.20", "@esbuild/win32-arm64": "0.18.20", "@esbuild/win32-ia32": "0.18.20", "@esbuild/win32-x64": "0.18.20" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA=="],
 
     "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
@@ -3679,6 +3683,16 @@
 
     "@expo/xcpretty/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
 
+    "@formatjs/ecma402-abstract/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@formatjs/fast-memoize/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@formatjs/icu-messageformat-parser/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@formatjs/icu-skeleton-parser/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@formatjs/intl-localematcher/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "@google/genai/ws": ["ws@8.19.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg=="],
 
     "@inquirer/core/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
@@ -3727,6 +3741,26 @@
 
     "@react-router/serve/express": ["express@4.22.1", "", { "dependencies": { "accepts": "~1.3.8", "array-flatten": "1.1.1", "body-parser": "~1.20.3", "content-disposition": "~0.5.4", "content-type": "~1.0.4", "cookie": "~0.7.1", "cookie-signature": "~1.0.6", "debug": "2.6.9", "depd": "2.0.0", "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", "finalhandler": "~1.3.1", "fresh": "~0.5.2", "http-errors": "~2.0.0", "merge-descriptors": "1.0.3", "methods": "~1.1.2", "on-finished": "~2.4.1", "parseurl": "~1.3.3", "path-to-regexp": "~0.1.12", "proxy-addr": "~2.0.7", "qs": "~6.14.0", "range-parser": "~1.2.1", "safe-buffer": "5.2.1", "send": "~0.19.0", "serve-static": "~1.16.2", "setprototypeof": "1.2.0", "statuses": "~2.0.1", "type-is": "~1.6.18", "utils-merge": "1.0.1", "vary": "~1.1.2" } }, "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g=="],
 
+    "@smithy/core/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/credential-provider-imds/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/fetch-http-handler/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/is-array-buffer/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/node-http-handler/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/signature-v4/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/types/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/util-buffer-from/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@smithy/util-utf8/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@swc/helpers/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "@tailwindcss/node/jiti": ["jiti@2.6.1", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ=="],
 
     "@tailwindcss/node/lightningcss": ["lightningcss@1.31.1", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.31.1", "lightningcss-darwin-arm64": "1.31.1", "lightningcss-darwin-x64": "1.31.1", "lightningcss-freebsd-x64": "1.31.1", "lightningcss-linux-arm-gnueabihf": "1.31.1", "lightningcss-linux-arm64-gnu": "1.31.1", "lightningcss-linux-arm64-musl": "1.31.1", "lightningcss-linux-x64-gnu": "1.31.1", "lightningcss-linux-x64-musl": "1.31.1", "lightningcss-win32-arm64-msvc": "1.31.1", "lightningcss-win32-x64-msvc": "1.31.1" } }, "sha512-l51N2r93WmGUye3WuFoN5k10zyvrVs0qfKBhyC5ogUQ6Ew6JUSswh78mbSO+IU3nTWsyOArqPCcShdQSadghBQ=="],
@@ -3751,8 +3785,6 @@
 
     "@ts-morph/common/minimatch": ["minimatch@10.2.4", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg=="],
 
-    "@tybys/wasm-util/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
     "@types/pg/@types/node": ["@types/node@22.19.15", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg=="],
 
     "@typescript-eslint/visitor-keys/eslint-visitor-keys": ["eslint-visitor-keys@5.0.1", "", {}, "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA=="],
@@ -3765,7 +3797,7 @@
 
     "anymatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
 
-    "aria-hidden/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
+    "ast-types/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
     "babel-plugin-polyfill-corejs2/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
@@ -3849,8 +3881,6 @@
 
     "expo-router/@expo/metro-runtime": ["@expo/metro-runtime@56.0.15", "", { "dependencies": { "@expo/log-box": "^56.0.13", "anser": "^1.4.9", "pretty-format": "^29.7.0", "stacktrace-parser": "^0.1.10", "whatwg-fetch": "^3.0.0" }, "peerDependencies": { "expo": "*", "react": "*", "react-dom": "*", "react-native": "*" }, "optionalPeers": ["react-dom"] }, "sha512-WIWeVsL6kCSB57oYZdUA4MTkH7c67UFMIjdNoQzKXwxZYwBFE/xL2cGPDC3z8RWt0femzJTVxAVZUOW/hiqRzA=="],
 
-    "expo-router/expo-glass-effect": ["expo-glass-effect@56.0.4", "", { "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }, "sha512-xI9rXtDwi7RW82uAlfyaXO6+k21ApWJ2tHAWYqPr/FjfmZbKsgNJ4Q0iZzGPCwboqjTGxaRZ61SZxBl8hDt5iA=="],
-
     "express/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
 
     "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
@@ -3861,6 +3891,8 @@
 
     "foreground-child/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
 
+    "framer-motion/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "freya-client/typescript": ["typescript@6.0.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw=="],
 
     "giget/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
@@ -3871,6 +3903,8 @@
 
     "import-fresh/resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
 
+    "intl-messageformat/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "jest-util/@types/node": ["@types/node@22.19.15", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg=="],
 
     "jest-util/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
@@ -3907,8 +3941,6 @@
 
     "morgan/on-finished": ["on-finished@2.3.0", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-ikqdkGAAyf/X/gPhXGvfgAytDZtDbr+bkNUJ0N9h5MI/dmdgCs3l6hoHrcUv41sRKew3jIwrp4qQDXiK99Utww=="],
 
-    "motion/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
     "node-exports-info/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
     "npm-package-arg/hosted-git-info": ["hosted-git-info@7.0.2", "", { "dependencies": { "lru-cache": "^10.0.1" } }, "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w=="],
@@ -3955,11 +3987,7 @@
 
     "react-native-web/memoize-one": ["memoize-one@6.0.0", "", {}, "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw=="],
 
-    "react-remove-scroll/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
+    "recast/tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
-
-    "react-remove-scroll-bar/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
-    "react-style-singleton/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
 
     "regjsparser/jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
 
@@ -3989,10 +4017,6 @@
 
     "twrnc/tailwindcss": ["tailwindcss@3.4.19", "", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "arg": "^5.0.2", "chokidar": "^3.6.0", "didyoumean": "^1.2.2", "dlv": "^1.1.3", "fast-glob": "^3.3.2", "glob-parent": "^6.0.2", "is-glob": "^4.0.3", "jiti": "^1.21.7", "lilconfig": "^3.1.3", "micromatch": "^4.0.8", "normalize-path": "^3.0.0", "object-hash": "^3.0.0", "picocolors": "^1.1.1", "postcss": "^8.4.47", "postcss-import": "^15.1.0", "postcss-js": "^4.0.1", "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0", "postcss-nested": "^6.2.0", "postcss-selector-parser": "^6.1.2", "resolve": "^1.22.8", "sucrase": "^3.35.0" }, "bin": { "tailwind": "lib/cli.js", "tailwindcss": "lib/cli.js" } }, "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ=="],
 
-    "use-callback-ref/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
-    "use-sidecar/tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
-
     "vite/esbuild": ["esbuild@0.27.3", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.3", "@esbuild/android-arm": "0.27.3", "@esbuild/android-arm64": "0.27.3", "@esbuild/android-x64": "0.27.3", "@esbuild/darwin-arm64": "0.27.3", "@esbuild/darwin-x64": "0.27.3", "@esbuild/freebsd-arm64": "0.27.3", "@esbuild/freebsd-x64": "0.27.3", "@esbuild/linux-arm": "0.27.3", "@esbuild/linux-arm64": "0.27.3", "@esbuild/linux-ia32": "0.27.3", "@esbuild/linux-loong64": "0.27.3", "@esbuild/linux-mips64el": "0.27.3", "@esbuild/linux-ppc64": "0.27.3", "@esbuild/linux-riscv64": "0.27.3", "@esbuild/linux-s390x": "0.27.3", "@esbuild/linux-x64": "0.27.3", "@esbuild/netbsd-arm64": "0.27.3", "@esbuild/netbsd-x64": "0.27.3", "@esbuild/openbsd-arm64": "0.27.3", "@esbuild/openbsd-x64": "0.27.3", "@esbuild/openharmony-arm64": "0.27.3", "@esbuild/sunos-x64": "0.27.3", "@esbuild/win32-arm64": "0.27.3", "@esbuild/win32-ia32": "0.27.3", "@esbuild/win32-x64": "0.27.3" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg=="],
 
     "vite-node/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],

flake.nix

@@ -53,9 +53,10 @@
       # so source-only edits do not force Bun to reinstall.
       dependencySource = lib.fileset.toSource {
         root = ./.;
-        fileset = lib.fileset.fileFilter (
+        fileset = lib.fileset.fileFilter
-          file: file.name == "bun.lock" || file.name == "package.json" || file.name == "bunfig.toml"
+          (
-        ) ./.;
+            file: file.name == "bun.lock" || file.name == "package.json" || file.name == "bunfig.toml"
+          ) ./.;
       };
 
       # Checks run against a clean source tree, even when using `path:.`.
@@ -92,10 +93,12 @@
         lib.mapAttrs mkBunScript scripts;
       mkBunApps =
         commands:
-        lib.mapAttrs (name: command: {
+        lib.mapAttrs
-          type = "app";
+          (name: command: {
-          program = "${command}/bin/${name}";
+            type = "app";
-        }) commands;
+            program = "${command}/bin/${name}";
+          })
+          commands;
       mkBunNodeModules =
         system: pkgs:
         pkgs.stdenvNoCC.mkDerivation {
@@ -255,6 +258,7 @@
             pkg-config
             postgresql
             python3
+            typescript-go
             watchman
           ];
           linuxPackages = with pkgs; [

package.json

@@ -29,8 +29,5 @@
 	},
 	"peerDependencies": {
 		"typescript": "^6"
-	},
-	"patchedDependencies": {
-		"@ark/schema@0.56.0": "patches/@ark%2Fschema@0.56.0.patch"
 	}
 }

packages/freya-agent-protocol/package.json

@@ -6,5 +6,8 @@
 	"types": "src/index.ts",
 	"scripts": {
 		"test": "bun test ./src"
+	},
+	"dependencies": {
+		"@freya/core": "workspace:*"
 	}
 }

packages/freya-agent-protocol/src/index.test.ts

@@ -1,12 +1,30 @@
 import { describe, expect, test } from "bun:test"
 
+import { ConversationEntryKind, ConversationEntryVisibility } from "@freya/core"
+
 import type { AgentEvent, AgentServerApi } from "./index"
 
 describe("agent protocol", () => {
 	test("defines server methods and agent events", () => {
 		const server: AgentServerApi = {
 			async sendMessage(message) {
-				return { message, conversationId: "conversation-1" }
+				return {
+					id: "entry-1",
+					conversationId: "conversation-1",
+					sequence: 1,
+					kind: ConversationEntryKind.UserMessage,
+					visibility: ConversationEntryVisibility.UserVisible,
+					fileId: null,
+					payload: {
+						role: "user",
+						parts: [{ type: "text", text: message }],
+					},
+					metadata: {},
+					createdAt: "2026-07-03T00:00:00.000Z",
+				}
+			},
+			notify() {
+				// no-op for protocol shape test
 			},
 			ping() {
 				return "pong"

packages/freya-agent-protocol/src/index.ts

@@ -1,7 +1,4 @@
-export interface SendMessageResult {
+import type { ConversationEntry } from "@freya/core"
-	message: string
-	conversationId: string
-}
 
 export type AgentEvent =
 	| { type: "conversation_started"; conversationId: string }
@@ -11,8 +8,11 @@ export type AgentEvent =
 	| { type: "message_finished" }
 	| { type: "message_failed"; error: string }
 
+export type UserEvent = { type: "typing" }
+
 export interface AgentServerApi {
-	sendMessage(message: string): Promise<SendMessageResult>
+	sendMessage(message: string): Promise<ConversationEntry>
+	notify(event: UserEvent): void
 	ping(): "pong"
 }
 

packages/freya-core/src/conversation.test.ts

@@ -4,7 +4,11 @@ import {
 	AttachmentType,
 	AttachmentPayload,
 	ContextSummaryPayload,
+	Conversation,
+	ConversationEntry,
+	ConversationEntryKind,
 	ConversationEntryMetadata,
+	ConversationEntryVisibility,
 	GenericObjectPayload,
 	UserMessagePayload,
 } from "./conversation"
@@ -143,4 +147,99 @@ describe("conversation entry schemas", () => {
 			}),
 		).toThrow()
 	})
+
+	test("parses conversation summaries", () => {
+		const conversation = Conversation.assert({
+			id: "11111111-1111-4111-8111-111111111111",
+			createdAt: "2026-06-17T09:30:00.000Z",
+			updatedAt: "2026-06-17T09:35:00.000Z",
+		})
+
+		expect(conversation.id).toBe("11111111-1111-4111-8111-111111111111")
+	})
+
+	test("parses kind-specific conversation entries", () => {
+		const userMessageEntry = ConversationEntry.assert({
+			id: "22222222-2222-4222-8222-222222222222",
+			conversationId: "11111111-1111-4111-8111-111111111111",
+			sequence: 1,
+			kind: ConversationEntryKind.UserMessage,
+			visibility: ConversationEntryVisibility.UserVisible,
+			fileId: null,
+			payload: {
+				role: "user",
+				parts: [{ type: "text", text: "hello" }],
+			},
+			metadata: {},
+			createdAt: "2026-06-17T09:30:00.000Z",
+		})
+		const attachmentEntry = ConversationEntry.assert({
+			id: "33333333-3333-4333-8333-333333333333",
+			conversationId: "11111111-1111-4111-8111-111111111111",
+			sequence: 2,
+			kind: ConversationEntryKind.Attachment,
+			visibility: ConversationEntryVisibility.UserVisible,
+			fileId: "44444444-4444-4444-8444-444444444444",
+			payload: {
+				role: "user",
+				name: "photo.png",
+				mimeType: "image/png",
+				attachmentType: AttachmentType.Image,
+			},
+			metadata: {},
+			createdAt: "2026-06-17T09:31:00.000Z",
+		})
+
+		expect(userMessageEntry.kind).toBe(ConversationEntryKind.UserMessage)
+		expect(attachmentEntry.kind).toBe(ConversationEntryKind.Attachment)
+	})
+
+	test("rejects conversation entries whose payload does not match the kind", () => {
+		expect(() =>
+			ConversationEntry.assert({
+				id: "22222222-2222-4222-8222-222222222222",
+				conversationId: "11111111-1111-4111-8111-111111111111",
+				sequence: 1,
+				kind: ConversationEntryKind.UserMessage,
+				visibility: ConversationEntryVisibility.UserVisible,
+				fileId: null,
+				payload: {
+					role: "assistant",
+					parts: [{ type: "text", text: "hello" }],
+				},
+				metadata: {},
+				createdAt: "2026-06-17T09:30:00.000Z",
+			}),
+		).toThrow()
+	})
+
+	test("rejects serialized conversations with extra fields", () => {
+		expect(() =>
+			Conversation.assert({
+				id: "11111111-1111-4111-8111-111111111111",
+				createdAt: "2026-06-17T09:30:00.000Z",
+				updatedAt: "2026-06-17T09:35:00.000Z",
+				title: "not yet part of the schema",
+			}),
+		).toThrow()
+	})
+
+	test("rejects file ids on non-attachment entries", () => {
+		expect(() =>
+			ConversationEntry.assert({
+				id: "22222222-2222-4222-8222-222222222222",
+				conversationId: "11111111-1111-4111-8111-111111111111",
+				sequence: 1,
+				kind: ConversationEntryKind.UserMessage,
+				visibility: ConversationEntryVisibility.UserVisible,
+				fileId: "44444444-4444-4444-8444-444444444444",
+				payload: {
+					role: "user",
+					parts: [{ type: "text", text: "hello" }],
+				},
+				metadata: {},
+				createdAt: "2026-06-17T09:30:00.000Z",
+			}),
+		).toThrow()
+	})
 })

packages/freya-core/src/conversation.ts

@@ -146,24 +146,143 @@ export const ConversationEntryMetadata = type({
 /** Metadata bag attached to a conversation entry. */
 export type ConversationEntryMetadata = typeof ConversationEntryMetadata.infer
 
+export const ToolCallPayload = type({
+	toolName: "string",
+})
+
+export type ToolCallPayload = typeof ToolCallPayload.infer
+
+export const ToolResultPayload = type({
+	toolName: "string",
+	ok: "boolean",
+})
+
+export type ToolResultPayload = typeof ToolResultPayload.infer
+
 /** Generic object payload used by operational entries. */
 export const GenericObjectPayload = type("Record<string, unknown>")
 
 /** Fallback payload shape for tool calls, tool results, and system notes. */
 export type GenericObjectPayload = typeof GenericObjectPayload.infer
 
-export const ConversationEntryPayload = type.or(
-	UserMessagePayload,
-	AssistantMessagePayload,
-	AttachmentPayload,
-	ContextSummaryPayload,
-	GenericObjectPayload,
-)
-
 /** Union of payload shapes that can be stored on a conversation entry. */
 export type ConversationEntryPayload =
 	| UserMessagePayload
 	| AssistantMessagePayload
 	| AttachmentPayload
 	| ContextSummaryPayload
+	| ToolCallPayload
+	| ToolResultPayload
 	| GenericObjectPayload
+
+export const Conversation = type({
+	"+": "reject",
+	id: "string.uuid",
+	createdAt: "string.date.iso",
+	updatedAt: "string.date.iso",
+})
+
+export type Conversation = typeof Conversation.infer
+
+export const UserMessageConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'user_message'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "null",
+	payload: UserMessagePayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const AssistantMessageConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'assistant_message'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "null",
+	payload: AssistantMessagePayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const AttachmentConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'attachment'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "string.uuid",
+	payload: AttachmentPayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const ToolCallConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'tool_call'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "null",
+	payload: GenericObjectPayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const ToolResultConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'tool_result'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "null",
+	payload: GenericObjectPayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const ContextSummaryConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'context_summary'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "null",
+	payload: ContextSummaryPayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const SystemNoteConversationEntry = type({
+	"+": "reject",
+	id: "string.uuid",
+	conversationId: "string.uuid",
+	sequence: "number.integer >= 1",
+	kind: "'system_note'",
+	visibility: type.enumerated(...Object.values(ConversationEntryVisibility)),
+	fileId: "null",
+	payload: GenericObjectPayload,
+	metadata: ConversationEntryMetadata,
+	createdAt: "string.date.iso",
+})
+
+export const ConversationEntry = type.or(
+	UserMessageConversationEntry,
+	AssistantMessageConversationEntry,
+	AttachmentConversationEntry,
+	ToolCallConversationEntry,
+	ToolResultConversationEntry,
+	ContextSummaryConversationEntry,
+	SystemNoteConversationEntry,
+)
+
+export type ConversationEntry = typeof ConversationEntry.infer

packages/freya-core/src/index.ts

@@ -1,84 +1,80 @@
 // Context
-export type { ContextEntry, ContextKey, ContextKeyPart } from "./context";
+export type { ContextEntry, ContextKey, ContextKeyPart } from "./context"
-export { Context, contextKey, serializeKey } from "./context";
+export { Context, contextKey, serializeKey } from "./context"
 
 // Actions
-export type { ActionDefinition } from "./action";
+export type { ActionDefinition } from "./action"
-export { UnknownActionError } from "./action";
+export { UnknownActionError } from "./action"
 
 // Conversation
+export type { ConversationEntryPayload } from "./conversation"
 export {
-  AssistantMessagePayload,
+	AssistantMessagePayload,
-  AttachmentPayload,
+	AssistantMessageConversationEntry,
-  AttachmentType,
+	AttachmentPayload,
-  ContextSummary,
+	AttachmentConversationEntry,
-  ContextSummaryPayload,
+	AttachmentType,
-  ConversationEntryKind,
+	ContextSummary,
-  ConversationEntryMetadata,
+	ContextSummaryConversationEntry,
-  ConversationEntryVisibility,
+	ContextSummaryPayload,
-  GenericObjectPayload,
+	Conversation,
-  JsonMessagePart,
+	ConversationEntry,
-  MessagePart,
+	ConversationEntryKind,
-  ModelRunMetadata,
+	ConversationEntryMetadata,
-  TextMessagePart,
+	ConversationEntryVisibility,
-  UserMessagePayload,
+	GenericObjectPayload,
-  ConversationEntryPayload,
+	JsonMessagePart,
-} from "./conversation";
+	MessagePart,
+	ModelRunMetadata,
+	SystemNoteConversationEntry,
+	TextMessagePart,
+	ToolCallConversationEntry,
+	ToolCallPayload,
+	ToolResultConversationEntry,
+	ToolResultPayload,
+	UserMessagePayload,
+	UserMessageConversationEntry,
+} from "./conversation"
 
 // Feed
-export type {
+export type { FeedItem, FeedItemRenderer, FeedItemSignals, RenderedFeedItem, Slot } from "./feed"
-  FeedItem,
+export { TimeRelevance } from "./feed"
-  FeedItemRenderer,
-  FeedItemSignals,
-  RenderedFeedItem,
-  Slot,
-} from "./feed";
-export { TimeRelevance } from "./feed";
 
 // Feed Source
-export type { FeedSource } from "./feed-source";
+export type { FeedSource } from "./feed-source"
 
 // Feed Post-Processor
-export type {
+export type { FeedEnhancement, FeedPostProcessor, ItemGroup } from "./feed-post-processor"
-  FeedEnhancement,
-  FeedPostProcessor,
-  ItemGroup,
-} from "./feed-post-processor";
 
 // Feed Engine
-export type {
+export type { FeedEngineConfig, FeedResult, FeedSubscriber, SourceError } from "./feed-engine"
-  FeedEngineConfig,
+export { FeedEngine } from "./feed-engine"
-  FeedResult,
-  FeedSubscriber,
-  SourceError,
-} from "./feed-engine";
-export { FeedEngine } from "./feed-engine";
 
 // =============================================================================
 // DEPRECATED - Use FeedSource + FeedEngine instead
 // =============================================================================
 
 // Data Source (deprecated - use FeedSource)
-export type { DataSource } from "./data-source";
+export type { DataSource } from "./data-source"
 
 // Context Provider (deprecated - use FeedSource)
-export type { ContextProvider } from "./context-provider";
+export type { ContextProvider } from "./context-provider"
 
 // Context Bridge (deprecated - use FeedEngine)
-export type { ProviderError, RefreshResult } from "./context-bridge";
+export type { ProviderError, RefreshResult } from "./context-bridge"
-export { ContextBridge } from "./context-bridge";
+export { ContextBridge } from "./context-bridge"
 
 // Reconciler (deprecated - use FeedEngine)
 export type {
-  ReconcileResult,
+	ReconcileResult,
-  ReconcilerConfig,
+	ReconcilerConfig,
-  SourceError as ReconcilerSourceError,
+	SourceError as ReconcilerSourceError,
-} from "./reconciler";
+} from "./reconciler"
-export { Reconciler } from "./reconciler";
+export { Reconciler } from "./reconciler"
 
 // Feed Controller (deprecated - use FeedEngine)
 export type {
-  FeedControllerConfig,
+	FeedControllerConfig,
-  FeedSubscriber as FeedControllerSubscriber,
+	FeedSubscriber as FeedControllerSubscriber,
-} from "./feed-controller";
+} from "./feed-controller"
-export { FeedController } from "./feed-controller";
+export { FeedController } from "./feed-controller"

patches/@ark%2Fschema@0.56.0.patch

@@ -1,23 +0,0 @@
-diff --git a/out/shared/disjoint.js b/out/shared/disjoint.js
-index 9fb94ad4f257b95225536eb5fdf20eaf6193b7a6..377af13b28807b1943f14240c1e889c3b16efe94 100644
---- a/out/shared/disjoint.js
-+++ b/out/shared/disjoint.js
-@@ -48,11 +48,17 @@ export class Disjoint extends Array {
-         return result;
-     }
-     withPrefixKey(key, kind) {
--        return this.map(entry => ({
-+        const result = this.map(entry => ({
-             ...entry,
-             path: [key, ...entry.path],
-             optional: entry.optional || kind === "optional"
-         }));
-+        // Workaround for Static Hermes, which doesn't preserve the Disjoint Array subclass here.
-+        // Mirrors the existing invert() guard added for https://github.com/arktypeio/arktype/issues/1027
-+        // and covers the same failure mode reported in https://github.com/arktypeio/arktype/issues/1415.
-+        if (!(result instanceof Disjoint))
-+            return new Disjoint(...result);
-+        return result;
-     }
-     toNeverIfDisjoint() {
-         return $ark.intrinsic.never;

patches/README.md

@@ -1,18 +0,0 @@
-# Dependency Patches
-
-## `@ark/schema@0.56.0`
-
-`@ark/schema` is patched for React Native/Hermes compatibility.
-
-ArkType's internal `Disjoint` type extends `Array`. In Hermes, `Array.prototype.map()`
-does not always preserve the subclass instance. If `Disjoint.withPrefixKey()` returns
-a plain array, later ArkType reduction code can call schema methods such as `isRoot()`
-on that array and crash during app startup.
-
-The patch mirrors ArkType's existing guard in `Disjoint.invert()` by wrapping the
-mapped result back into `new Disjoint(...)` when Hermes returns a plain array.
-
-Upstream context:
-
-- https://github.com/arktypeio/arktype/issues/1415
-- https://github.com/arktypeio/arktype/issues/1027