refactor: move conversation types to core (#149)

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

@@ -1,3 +1,4 @@
+import { ConversationEntryKind } from "@freya/core"
 import { describe, expect, test } from "bun:test"
 
 import type { AppendConversationEntryInput } from "../conversations/storage.ts"
@@ -6,7 +7,6 @@ import type {
 	ConversationStorageEntry,
 } from "./conversation-recording-query-agent.ts"
 
-import { ConversationEntryKind } from "../conversations/types.ts"
 import { ConversationRecordingQueryAgent } from "./conversation-recording-query-agent.ts"
 import {
 	createQueryAgentEventListeners,

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

@@ -1,12 +1,13 @@
+import type { ConversationEntryMetadata } from "@freya/core"
+
+import { ConversationEntryKind } from "@freya/core"
 import { randomUUID } from "node:crypto"
 
 import type {
 	AppendConversationEntryInput,
 	ConversationEntryRow,
 } from "../conversations/storage.ts"
-import type { ConversationEntryMetadata } from "../conversations/types.ts"
 
-import { ConversationEntryKind } from "../conversations/types.ts"
 import {
 	createQueryAgentEventListeners,
 	QueryAgentEvent,
@@ -19,6 +20,7 @@ import {
 	type QueryAgentStreamEvent,
 } from "./query-agent.ts"
 
+/** Storage operations used to persist and replay query-agent conversation entries. */
 export interface ConversationStorage {
 	getOrCreateConversation(): Promise<{ id: string }>
 	appendEntry(
@@ -28,11 +30,13 @@ export interface ConversationStorage {
 	listEntries(conversationId: string): Promise<ConversationStorageEntry[]>
 }
 
+/** Minimal persisted entry shape needed by recording and replay agents. */
 export type ConversationStorageEntry = Pick<
 	ConversationEntryRow,
 	"id" | "sequence" | "kind" | "payload" | "metadata" | "createdAt"
 >
 
+/** Configuration for wrapping a QueryAgent with conversation recording. */
 export interface ConversationRecordingQueryAgentConfig {
 	agent: QueryAgent
 	storage: ConversationStorage

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

@@ -1,9 +1,9 @@
+import { ConversationEntryKind } from "@freya/core"
 import { beforeEach, describe, expect, mock, test } from "bun:test"
 
 import type { QueryAgentToolbox } from "./query-agent-toolbox.ts"
 import type { QueryAgentStreamEvent } from "./query-agent.ts"
 
-import { ConversationEntryKind } from "../conversations/types.ts"
 import { QueryAgentEvent } from "./query-agent.ts"
 
 interface FakePiSession {

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

@@ -33,13 +33,25 @@ import {
 import { createSessionManager } from "./session-manager.ts"
 import { createFreyaAgentTools, FREYA_AGENT_TOOL_NAMES } from "./tools.ts"
 
+/** Active Pi SDK session instance returned by createAgentSession. */
 type PiSession = Awaited<ReturnType<typeof createAgentSession>>["session"]
+
+/** Pi event emitted when a message finishes. */
 type PiMessageEndEvent = Extract<AgentSessionEvent, { type: "message_end" }>
+
+/** Message payload carried by Pi's message-end event. */
 type PiAgentMessage = PiMessageEndEvent["message"]
+
+/** Pi event emitted when an agent run finishes. */
 type PiAgentEndEvent = Extract<AgentSessionEvent, { type: "agent_end" }>
+
+/** Session manager created for Pi conversation replay. */
 type PiSessionManager = ReturnType<typeof createSessionManager>
+
+/** Message shape accepted by the replay session manager. */
 type PiSessionMessage = Parameters<PiSessionManager["appendMessage"]>[0]
 
+/** Configuration for the Pi-backed query agent. */
 export interface PiQueryAgentConfig {
 	toolbox: QueryAgentToolbox
 	apiKey?: string

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

@@ -1,8 +1,8 @@
+import { ConversationEntryKind } from "@freya/core"
 import { describe, expect, test } from "bun:test"
 
 import type { ConversationStorageEntry } from "./conversation-recording-query-agent.ts"
 
-import { ConversationEntryKind } from "../conversations/types.ts"
 import { createSessionManager } from "./session-manager.ts"
 
 describe("createSessionManager", () => {

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

@@ -1,18 +1,21 @@
 import { SessionManager } from "@earendil-works/pi-coding-agent"
-import { tmpdir } from "node:os"
-
-import type { ConversationStorageEntry } from "./conversation-recording-query-agent.ts"
-
 import {
 	AssistantMessagePayload,
 	ContextSummaryPayload,
 	ConversationEntryKind,
 	UserMessagePayload,
-} from "../conversations/types.ts"
+} from "@freya/core"
+import { tmpdir } from "node:os"
 
+import type { ConversationStorageEntry } from "./conversation-recording-query-agent.ts"
+
+/** Message shape accepted by Pi's SessionManager.appendMessage API. */
 type PiMessage = Parameters<SessionManager["appendMessage"]>[0]
+
+/** Assistant message variant required when replaying stored assistant entries. */
 type PiAssistantMessage = Extract<PiMessage, { role: "assistant" }>
 
+/** Inputs required to rebuild a Pi session manager from stored conversation entries. */
 export interface CreateSessionManagerInput {
 	cwd?: string
 	entries: ConversationStorageEntry[]

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

@@ -1,3 +1,4 @@
+import { ConversationEntryKind, ConversationEntryVisibility } from "@freya/core"
 import { beforeEach, describe, expect, mock, test } from "bun:test"
 import { Hono } from "hono"
 
@@ -11,7 +12,6 @@ import type {
 import { mockAuthSessionMiddleware } from "../auth/session-middleware.ts"
 import { ConversationNotFoundError } from "./errors.ts"
 import { registerConversationsHttpHandlers } from "./http.ts"
-import { ConversationEntryKind, ConversationEntryVisibility } from "./types.ts"
 
 const MockUserId = "k7Gx2mPqRvNwYs9TdLfA4bHcJeUo1iZn"
 const ConversationId = "11111111-1111-4111-8111-111111111111"

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

@@ -1,5 +1,6 @@
 import type { Context, Hono } from "hono"
 
+import { ConversationEntryVisibility } from "@freya/core"
 import { type } from "arktype"
 import { createMiddleware } from "hono/factory"
 
@@ -9,20 +10,22 @@ import type { ConversationRow } from "./storage.ts"
 
 import { ConversationNotFoundError } from "./errors.ts"
 import { conversations } from "./storage.ts"
-import { ConversationEntryVisibility } from "./types.ts"
 
+/** Hono environment populated by the conversations route middleware. */
 type Env = {
 	Variables: {
 		db: Database
 	}
 }
 
+/** 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

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

@@ -1,17 +1,18 @@
+import {
+	AssistantMessagePayload,
+	AttachmentPayload,
+	ConversationEntryKind,
+	ConversationEntryVisibility,
+	ContextSummaryPayload,
+	ConversationEntryMetadata,
+	GenericObjectPayload,
+	UserMessagePayload,
+	type ConversationEntryPayload,
+} from "@freya/core"
+import { type } from "arktype"
 import { and, asc, desc, eq } from "drizzle-orm"
 
 import type { Database } from "../db/index.ts"
-import type {
-	AssistantMessagePayload,
-	AttachmentPayload,
-	ContextSummaryPayload,
-	ConversationEntryKind as ConversationEntryKindType,
-	ConversationEntryMetadata,
-	ConversationEntryPayload,
-	ConversationEntryVisibility as ConversationEntryVisibilityType,
-	GenericObjectPayload,
-	UserMessagePayload,
-} from "./types.ts"
 
 import {
 	conversationEntries,
@@ -20,23 +21,20 @@ import {
 	user,
 } from "../db/schema.ts"
 import { ConversationNotFoundError } from "./errors.ts"
-import {
-	ConversationEntryMetadata as ConversationEntryMetadataSchema,
-	AssistantMessagePayload as AssistantMessagePayloadSchema,
-	AttachmentPayload as AttachmentPayloadSchema,
-	ConversationEntryKind,
-	ConversationEntryKindInput,
-	ConversationEntryVisibility,
-	ConversationEntryVisibilityInput,
-	ContextSummaryPayload as ContextSummaryPayloadSchema,
-	GenericObjectPayload as GenericObjectPayloadSchema,
-	UserMessagePayload as UserMessagePayloadSchema,
-} from "./types.ts"
 
+const conversationEntryKind = type.enumerated(...Object.values(ConversationEntryKind))
+const conversationEntryVisibility = type.enumerated(...Object.values(ConversationEntryVisibility))
+
+/** Database row shape for a conversation owned by a user. */
 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 an uploaded file referenced by conversations. */
 export type FileRow = typeof files.$inferSelect
 
+/** Input required to create a stored file record. */
 export interface CreateFileInput {
 	storageKey: string
 	originalName?: string
@@ -45,23 +43,27 @@ export interface CreateFileInput {
 	metadata?: Record<string, unknown>
 }
 
+/** Input for creating a file and appending its attachment entry together. */
 export interface AppendAttachmentEntryInput {
 	file: CreateFileInput
 	payload: AttachmentPayload
-	visibility?: ConversationEntryVisibilityType
+	visibility?: ConversationEntryVisibility
 	metadata?: ConversationEntryMetadata
 }
 
+/** Result returned after a file-backed attachment entry is appended. */
 export interface AppendAttachmentEntryResult {
 	file: FileRow
 	entry: ConversationEntryRow
 }
 
+/** Common fields accepted when appending any conversation entry. */
 interface AppendConversationEntryBase {
-	visibility?: ConversationEntryVisibilityType
+	visibility?: ConversationEntryVisibility
 	metadata?: ConversationEntryMetadata
 }
 
+/** Discriminated input for appending any supported entry kind to a conversation. */
 export type AppendConversationEntryInput =
 	| (AppendConversationEntryBase & {
 			kind: typeof ConversationEntryKind.UserMessage
@@ -92,8 +94,9 @@ export type AppendConversationEntryInput =
 			fileId?: never
 	  })
 
+/** Filters accepted when listing conversation entries. */
 export interface ListConversationEntriesParams {
-	visibility?: ConversationEntryVisibilityType
+	visibility?: ConversationEntryVisibility
 }
 
 export function conversations(db: Database, userId: string) {
@@ -140,12 +143,12 @@ export function conversations(db: Database, userId: string) {
 			conversationId: string,
 			input: AppendConversationEntryInput,
 		): Promise<ConversationEntryRow> {
-			const kind = ConversationEntryKindInput.assert(input.kind)
-			const visibility = ConversationEntryVisibilityInput.assert(
+			const kind = conversationEntryKind.assert(input.kind)
+			const visibility = conversationEntryVisibility.assert(
 				input.visibility ?? defaultVisibilityForKind(kind),
 			)
 			const payload = payloadForKind(kind, input.payload)
-			const metadata = ConversationEntryMetadataSchema.assert(input.metadata ?? {})
+			const metadata = ConversationEntryMetadata.assert(input.metadata ?? {})
 			let fileId: string | null = null
 
 			if (input.kind === ConversationEntryKind.Attachment) {
@@ -183,11 +186,11 @@ export function conversations(db: Database, userId: string) {
 			conversationId: string,
 			input: AppendAttachmentEntryInput,
 		): Promise<AppendAttachmentEntryResult> {
-			const payload = AttachmentPayloadSchema.assert(input.payload)
-			const visibility = ConversationEntryVisibilityInput.assert(
+			const payload = AttachmentPayload.assert(input.payload)
+			const visibility = conversationEntryVisibility.assert(
 				input.visibility ?? defaultVisibilityForKind(ConversationEntryKind.Attachment),
 			)
-			const metadata = ConversationEntryMetadataSchema.assert(input.metadata ?? {})
+			const metadata = ConversationEntryMetadata.assert(input.metadata ?? {})
 
 			return db.transaction(async (tx) => {
 				if (!(await findConversationForUpdate(tx, userId, conversationId))) {
@@ -250,22 +253,22 @@ export function conversations(db: Database, userId: string) {
 }
 
 function payloadForKind(
-	kind: ConversationEntryKindType,
+	kind: ConversationEntryKind,
 	payload: AppendConversationEntryInput["payload"],
 ): ConversationEntryPayload {
 	switch (kind) {
 		case ConversationEntryKind.UserMessage:
-			return UserMessagePayloadSchema.assert(payload)
+			return UserMessagePayload.assert(payload)
 		case ConversationEntryKind.AssistantMessage:
-			return AssistantMessagePayloadSchema.assert(payload)
+			return AssistantMessagePayload.assert(payload)
 		case ConversationEntryKind.Attachment:
-			return AttachmentPayloadSchema.assert(payload)
+			return AttachmentPayload.assert(payload)
 		case ConversationEntryKind.ContextSummary:
-			return ContextSummaryPayloadSchema.assert(payload)
+			return ContextSummaryPayload.assert(payload)
 		case ConversationEntryKind.ToolCall:
 		case ConversationEntryKind.ToolResult:
 		case ConversationEntryKind.SystemNote:
-			return GenericObjectPayloadSchema.assert(payload)
+			return GenericObjectPayload.assert(payload)
 	}
 }
 
@@ -371,9 +374,7 @@ function requireRow<T>(rows: T[], message = "Expected database row"): T {
 	return row
 }
 
-function defaultVisibilityForKind(
-	kind: ConversationEntryKindType,
-): ConversationEntryVisibilityType {
+function defaultVisibilityForKind(kind: ConversationEntryKind): ConversationEntryVisibility {
 	switch (kind) {
 		case ConversationEntryKind.UserMessage:
 		case ConversationEntryKind.AssistantMessage:

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

@@ -1,146 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import {
-	AttachmentType,
-	AttachmentPayload,
-	ContextSummaryPayload,
-	ConversationEntryMetadata,
-	GenericObjectPayload,
-	UserMessagePayload,
-} from "./types.ts"
-
-describe("conversation entry schemas", () => {
-	test("parses valid user message payloads", () => {
-		const payload = UserMessagePayload.assert({
-			role: "user",
-			parts: [{ type: "text", text: "hello" }],
-		})
-
-		expect(payload).toEqual({
-			role: "user",
-			parts: [{ type: "text", text: "hello" }],
-		})
-	})
-
-	test("rejects user message payloads with the wrong role", () => {
-		expect(() =>
-			UserMessagePayload.assert({
-				role: "assistant",
-				parts: [{ type: "text", text: "hello" }],
-			}),
-		).toThrow()
-	})
-
-	test("rejects user message payloads with no parts", () => {
-		expect(() =>
-			UserMessagePayload.assert({
-				role: "user",
-				parts: [],
-			}),
-		).toThrow()
-	})
-
-	test("parses valid attachment payloads", () => {
-		const payload = AttachmentPayload.assert({
-			role: "user",
-			name: "whiteboard.png",
-			mimeType: "image/png",
-			attachmentType: AttachmentType.Image,
-			caption: "whiteboard sketch",
-		})
-
-		expect(payload).toEqual({
-			role: "user",
-			name: "whiteboard.png",
-			mimeType: "image/png",
-			attachmentType: AttachmentType.Image,
-			caption: "whiteboard sketch",
-		})
-	})
-
-	test("rejects extra fields on structured payloads", () => {
-		expect(() =>
-			AttachmentPayload.assert({
-				role: "user",
-				name: "whiteboard.png",
-				mimeType: "image/png",
-				attachmentType: AttachmentType.Image,
-				fileId: "file-1",
-			}),
-		).toThrow()
-	})
-
-	test("parses context summary payloads", () => {
-		const payload = ContextSummaryPayload.assert({
-			covers: {
-				startSequence: 1,
-				endSequence: 12,
-			},
-			summary: {
-				userIntent: "Design message storage.",
-				durableFacts: [],
-				preferences: ["Keep the schema simple."],
-				decisions: ["Use conversation_entries as the timeline."],
-				openTasks: [],
-				importantDetails: [],
-			},
-			promptVersion: "conversation-summary-v1",
-			sourceEntryIds: ["entry-1", "entry-2"],
-		})
-
-		expect(payload).toMatchObject({
-			covers: {
-				startSequence: 1,
-				endSequence: 12,
-			},
-			promptVersion: "conversation-summary-v1",
-		})
-	})
-
-	test("allows generic object payloads for tool entries", () => {
-		const payload = GenericObjectPayload.assert({
-			toolCallId: "call-1",
-			toolName: "calendar.search",
-			input: { date: "2026-06-15" },
-		})
-
-		expect(payload).toEqual({
-			toolCallId: "call-1",
-			toolName: "calendar.search",
-			input: { date: "2026-06-15" },
-		})
-	})
-
-	test("rejects non-object generic payloads", () => {
-		expect(() => GenericObjectPayload.assert("done")).toThrow()
-	})
-
-	test("parses model run metadata and allows extra top-level metadata", () => {
-		const metadata = ConversationEntryMetadata.assert({
-			modelRun: {
-				route: "default-chat",
-				provider: "pi",
-				model: "pi-model",
-				inputTokens: 120,
-				outputTokens: 24,
-			},
-			traceId: "trace-1",
-		})
-
-		expect(metadata.modelRun?.model).toBe("pi-model")
-		expect(metadata.traceId).toBe("trace-1")
-	})
-
-	test("rejects invalid model run metadata", () => {
-		expect(() =>
-			ConversationEntryMetadata.assert({
-				modelRun: {
-					route: "default-chat",
-					provider: "pi",
-					model: "pi-model",
-					inputTokens: -1,
-				},
-			}),
-		).toThrow()
-	})
-})

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

@@ -1,136 +0,0 @@
-import { type } from "arktype"
-
-export const ConversationEntryKind = {
-	UserMessage: "user_message",
-	AssistantMessage: "assistant_message",
-	Attachment: "attachment",
-	ToolCall: "tool_call",
-	ToolResult: "tool_result",
-	ContextSummary: "context_summary",
-	SystemNote: "system_note",
-} as const
-
-export type ConversationEntryKind =
-	(typeof ConversationEntryKind)[keyof typeof ConversationEntryKind]
-
-export const ConversationEntryVisibility = {
-	UserVisible: "user_visible",
-	Internal: "internal",
-} as const
-
-export type ConversationEntryVisibility =
-	(typeof ConversationEntryVisibility)[keyof typeof ConversationEntryVisibility]
-
-export const AttachmentType = {
-	Image: "image",
-	Audio: "audio",
-	Video: "video",
-	Document: "document",
-	Other: "other",
-} as const
-
-export type AttachmentType = (typeof AttachmentType)[keyof typeof AttachmentType]
-
-export const ConversationEntryKindInput = type.enumerated(...Object.values(ConversationEntryKind))
-export const ConversationEntryVisibilityInput = type.enumerated(
-	...Object.values(ConversationEntryVisibility),
-)
-export const AttachmentTypeInput = type.enumerated(...Object.values(AttachmentType))
-
-const TextMessagePart = type({
-	"+": "reject",
-	type: "'text'",
-	text: "string",
-})
-
-const JsonMessagePart = type({
-	"+": "reject",
-	type: "'json'",
-	value: "unknown",
-})
-
-export const MessagePart = type.or(TextMessagePart, JsonMessagePart)
-export type MessagePart = typeof MessagePart.infer
-
-export const UserMessagePayload = type({
-	"+": "reject",
-	role: "'user'",
-	parts: MessagePart.array().atLeastLength(1),
-})
-
-export type UserMessagePayload = typeof UserMessagePayload.infer
-
-export const AssistantMessagePayload = type({
-	"+": "reject",
-	role: "'assistant'",
-	parts: MessagePart.array().atLeastLength(1),
-})
-
-export type AssistantMessagePayload = typeof AssistantMessagePayload.infer
-
-export const AttachmentPayload = type({
-	"+": "reject",
-	role: type.enumerated("user", "assistant"),
-	name: "string",
-	mimeType: "string",
-	attachmentType: AttachmentTypeInput,
-	"caption?": "string",
-})
-
-export type AttachmentPayload = typeof AttachmentPayload.infer
-
-const ContextSummary = type({
-	"+": "reject",
-	"userIntent?": "string",
-	durableFacts: type.string.array(),
-	preferences: type.string.array(),
-	decisions: type.string.array(),
-	openTasks: type.string.array(),
-	importantDetails: type.string.array(),
-})
-
-export const ContextSummaryPayload = type({
-	"+": "reject",
-	covers: type({
-		"+": "reject",
-		startSequence: "number.integer >= 1",
-		endSequence: "number.integer >= 1",
-	}),
-	summary: ContextSummary,
-	promptVersion: "string",
-	"sourceEntryIds?": type.string.array(),
-})
-
-export type ContextSummaryPayload = typeof ContextSummaryPayload.infer
-
-export const ModelRunMetadata = type({
-	"+": "reject",
-	route: "string",
-	provider: "string",
-	model: "string",
-	"contextSummaryEntryId?": "string",
-	"rawEntriesStartSequence?": "number.integer >= 1",
-	"rawEntriesEndSequence?": "number.integer >= 1",
-	"inputTokens?": "number.integer >= 0",
-	"outputTokens?": "number.integer >= 0",
-	"providerRequestId?": "string",
-})
-
-export type ModelRunMetadata = typeof ModelRunMetadata.infer
-
-export const ConversationEntryMetadata = type({
-	"modelRun?": ModelRunMetadata,
-	"[string]": "unknown",
-})
-
-export type ConversationEntryMetadata = typeof ConversationEntryMetadata.infer
-
-export const GenericObjectPayload = type("Record<string, unknown>")
-export type GenericObjectPayload = typeof GenericObjectPayload.infer
-
-export type ConversationEntryPayload =
-	| UserMessagePayload
-	| AssistantMessagePayload
-	| AttachmentPayload
-	| ContextSummaryPayload
-	| GenericObjectPayload

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

@@ -1,3 +1,10 @@
+import {
+	ConversationEntryVisibility,
+	type ConversationEntryKind,
+	type ConversationEntryMetadata,
+	type ConversationEntryPayload,
+	type ConversationEntryVisibility as ConversationEntryVisibilityType,
+} from "@freya/core"
 import { sql } from "drizzle-orm"
 import {
 	boolean,
@@ -13,14 +20,6 @@ import {
 	uuid,
 } from "drizzle-orm/pg-core"
 
-import {
-	ConversationEntryVisibility,
-	type ConversationEntryKind,
-	type ConversationEntryMetadata,
-	type ConversationEntryPayload,
-	type ConversationEntryVisibility as ConversationEntryVisibilityType,
-} from "../conversations/types.ts"
-
 // ---------------------------------------------------------------------------
 // Better Auth core tables
 // Re-exported from CLI-generated schema.

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

@@ -1,5 +1,6 @@
 import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
+import { ConversationEntryKind } from "@freya/core"
 import { LocationSource } from "@freya/source-location"
 import { WeatherSource } from "@freya/source-weatherkit"
 import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test"
@@ -9,7 +10,6 @@ import type { AppendConversationEntryInput } from "../conversations/storage.ts"
 import type { Database } from "../db/index.ts"
 import type { FeedSourceProvider } from "./feed-source-provider.ts"
 
-import { ConversationEntryKind } from "../conversations/types.ts"
 import { CredentialEncryptor } from "../lib/crypto.ts"
 import {
 	CredentialStorageUnavailableError,

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

@@ -1,5 +1,6 @@
 import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
+import { ConversationEntryKind } from "@freya/core"
 import { LocationSource } from "@freya/source-location"
 import { describe, expect, spyOn, test } from "bun:test"
 
@@ -9,7 +10,6 @@ import type {
 } from "../agent/conversation-recording-query-agent.ts"
 import type { AppendConversationEntryInput } from "../conversations/storage.ts"
 
-import { ConversationEntryKind } from "../conversations/types.ts"
 import { UserSession } from "./user-session.ts"
 
 function createStubSource(id: string, items: FeedItem[] = []): FeedSource {