AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
import { learnCompanionPreferences, refreshCompanionPreferences, applicableMemories } from "./companion-learning";
import { selectCompanionMemories } from "./companion-memory-context";
import { CompanionDiscoveryOutputSchema, companionTurnLocale, type CompanionDiscoveryOutput, type CompanionDiscoveryItem, type CompanionDiscoverySettings,
type CompanionDiscoverySettingsInput, type MemoDetail } from "@edgeever/shared";
import type { DatabaseAdapter } from "./storage-contract";
import type { CompanionScope } from "./companion-service";
import { beginCompanionTurn, checkpointCompanionTurn, listCompanionMemories, saveCompanionMemory, getCompanionTurn, companionRevision } from "./companion-service";
import { AppError } from "./app-error";
import { getMemoDetail, searchMemoSummaries } from "./memo-service";
import { companionWorkspaceCursor, proposeCompanionToolAction, workspaceCursorSql } from "./companion-tool-actions";
import { getCompanionAction } from "./companion-actions";
type DiscoveryModel = { modelId: string };
import { discoveryContext, discoveryInputHash, type DiscoveryContextInput } from "./companion-discovery-context";
type SettingsRow = { learning_enabled: number; recall_enabled: number; last_memory_revision: number; enabled: number; version: number; last_cursor: number;
last_check_at: string | null; last_status: CompanionDiscoverySettings["lastStatus"]; active_turn_id: string | null; last_input_hash: string | null };
type FeedRow = { memory_ids_json: string; id: string; kind: CompanionDiscoveryItem["kind"]; title: string; body: string; action_id: string | null;
sources_json: string; seen_at: string | null; created_at: string };
const keys = (scope: CompanionScope) => [scope.workspaceId, scope.ownerId];
const changed = () => new AppError("companion_discovery_conflict", "Discovery settings or notes changed. Refresh before continuing.", 409);
const plainText = (node: MemoDetail["contentJson"]): boolean => {
const visit = (value: unknown): boolean => {
if (!value || typeof value !== "object") return false;
const item = value as { type?: string; marks?: unknown[]; content?: unknown[]; attrs?: Record<string, unknown> };
return ["doc", "paragraph", "text", "hardBreak"].includes(item.type ?? "") && !item.marks?.length
&& (!item.attrs || Object.values(item.attrs).every(attribute => attribute === null))
&& (!item.content || item.content.every(visit));
};
return visit(node);
};
const settingsRow = (db: DatabaseAdapter, scope: CompanionScope) => db.prepare(
"SELECT * FROM companion_discovery_settings WHERE workspace_id = ? AND owner_id = ?").bind(...keys(scope)).first<SettingsRow>();
export async function getDiscoverySettings(db: DatabaseAdapter, scope: CompanionScope): Promise<CompanionDiscoverySettings> {
const row = await settingsRow(db, scope);
return { enabled: row?.enabled === 1, learningEnabled: row?.learning_enabled === 1, useMemory: row?.recall_enabled === 1, version: row?.version ?? 0,
lastCheckAt: row?.last_check_at ?? null,
lastStatus: row?.last_status === "running" && Date.now() - Date.parse(row.last_check_at ?? "") > 90_000 ? "failed" : row?.last_status ?? "quiet" };
}
export async function saveDiscoverySettings(db: DatabaseAdapter, scope: CompanionScope, input: CompanionDiscoverySettingsInput) {
await db.prepare("INSERT OR IGNORE INTO companion_discovery_settings(workspace_id, owner_id) VALUES (?, ?)").bind(...keys(scope)).run();
await db.prepare("INSERT OR IGNORE INTO companion_state(workspace_id, owner_id) VALUES (?, ?)").bind(...keys(scope)).run();
const previous = await settingsRow(db, scope);
const learning = input.learningEnabled ?? previous?.learning_enabled === 1;
const useMemory = input.useMemory ?? previous?.recall_enabled === 1;
const check = crypto.randomUUID();
await db.batch([
db.prepare(`INSERT INTO companion_action_checks(id, valid) VALUES (?, CASE WHEN EXISTS (
SELECT 1 FROM companion_discovery_settings WHERE workspace_id = ? AND owner_id = ? AND version = ?) THEN 1 ELSE 0 END)`)
.bind(check, ...keys(scope), input.version),
db.prepare("UPDATE companion_state SET memory_revision = memory_revision + 1 WHERE workspace_id = ? AND owner_id = ?").bind(...keys(scope)),
db.prepare("UPDATE companion_turns SET status = 'cancelled' WHERE workspace_id = ? AND owner_id = ? AND status = 'running'").bind(...keys(scope)),
// Revoke unconfirmed work atomically with settings. Already-started user
// confirmations retain their receipt and are allowed to finish.
db.prepare(`UPDATE companion_turns SET status = 'cancelled' WHERE workspace_id = ? AND owner_id = ?
AND (id IN (SELECT turn_id FROM companion_discoveries WHERE workspace_id = ? AND owner_id = ?)
OR id = (SELECT active_turn_id FROM companion_discovery_settings WHERE workspace_id = ? AND owner_id = ?))
AND NOT EXISTS (SELECT 1 FROM companion_actions a WHERE a.turn_id = companion_turns.id AND (a.execution_token IS NOT NULL OR a.status = 'applied'))`)
.bind(...keys(scope), ...keys(scope), ...keys(scope)),
// Keep the old storage column for migration compatibility, not permissions.
db.prepare(`UPDATE companion_discovery_settings SET enabled = ?, learning_cursor = CASE WHEN ? = 1 AND (learning_enabled = 0 OR enabled = 0)
THEN (SELECT COALESCE(MAX(rowid), 0) FROM audit_events) ELSE learning_cursor END,
learning_enabled = ?, recall_enabled = ?, last_memory_revision = -1, notebook_ids_json = '[]', version = version + 1,
last_status = 'quiet', active_turn_id = NULL WHERE workspace_id = ? AND owner_id = ?`)
.bind(Number(input.enabled), Number(learning), Number(learning), Number(useMemory), ...keys(scope)),
db.prepare("DELETE FROM companion_action_checks WHERE id = ?").bind(check),
]).catch(error => { if (/constraint/i.test(String(error))) throw changed(); throw error; });
return getDiscoverySettings(db, scope);
}
export async function listDiscoveries(db: DatabaseAdapter, scope: CompanionScope): Promise<CompanionDiscoveryItem[]> {
const memories = await listCompanionMemories(db, scope);
const rows = await db.prepare(`SELECT d.* FROM companion_discoveries d JOIN companion_discovery_settings s
ON s.workspace_id = d.workspace_id AND s.owner_id = d.owner_id
JOIN companion_turns t ON t.id = d.turn_id JOIN companion_state cs ON cs.workspace_id = d.workspace_id AND cs.owner_id = d.owner_id
WHERE d.workspace_id = ? AND d.owner_id = ? AND s.enabled = 1 AND s.version = d.settings_version
AND d.dismissed_at IS NULL AND t.status = 'completed' AND t.memory_revision = cs.memory_revision
AND d.created_at > ? ORDER BY d.created_at DESC LIMIT 20`)
.bind(...keys(scope), new Date(Date.now() - 7 * 86400000).toISOString()).all<FeedRow>();
const items: CompanionDiscoveryItem[] = [];
for (const row of rows.results) {
const sources = JSON.parse(row.sources_json) as CompanionDiscoveryItem["sources"];
const action = row.action_id ? await getCompanionAction(db, scope, row.action_id) : null;
// Keep applied receipts, but never re-display old excerpts or model text
// about a deleted/edited note in a pending discovery.
if (action?.status !== "applied") {
let valid = true;
for (const source of sources) {
const memo = await db.prepare(`SELECT m.notebook_id, c.revision FROM memos m JOIN memo_contents c ON c.memo_id = m.id
WHERE m.id = ? AND m.workspace_id = ? AND m.is_deleted = 0`).bind(source.id, scope.workspaceId)
.first<{ notebook_id: string; revision: number }>();
if (!memo || memo.revision !== source.revision || memo.notebook_id !== source.notebookId) { valid = false; break; }
}
if (!valid || (action && action.status !== "pending" && action.status !== "uncertain")) continue;
}
items.push({ id: row.id, kind: row.kind, title: row.title, body: row.body, sources, action,
memories: (JSON.parse(row.memory_ids_json) as string[]).flatMap(id => {
const memory = memories.find(m => m.id === id); return memory ? [memory] : [];
}), seen: row.seen_at !== null, createdAt: row.created_at });
}
return items;
}
export async function acknowledgeDiscovery(db: DatabaseAdapter, scope: CompanionScope, id: string, dismiss: boolean) {
const now = new Date().toISOString();
await db.batch([
db.prepare(`UPDATE companion_discoveries SET seen_at = COALESCE(seen_at, ?)${dismiss ? ", dismissed_at = ?" : ""}
WHERE workspace_id = ? AND owner_id = ? AND id = ?`).bind(now, ...(dismiss ? [now] : []), ...keys(scope), id),
...(dismiss ? [db.prepare(`UPDATE companion_actions SET status = 'dismissed' WHERE workspace_id = ? AND owner_id = ?
AND status = 'pending' AND execution_token IS NULL AND id IN (SELECT action_id FROM companion_discoveries WHERE id = ? AND workspace_id = ? AND owner_id = ?)`)
.bind(...keys(scope), id, ...keys(scope))] : []),
]);
}
// Bounded SQL retrieval, no embeddings, background worker or full-library body
// scan. Prefer recent fragments plus keyword matches from older notes.
async function candidatesFor(db: DatabaseAdapter, scope: CompanionScope) {
// Permission covers the entire current workspace, including new/child
// notebooks. Retrieval budgets are global, never multiplied by notebook count.
const recent = (await searchMemoSummaries(db, { workspaceId: scope.workspaceId, limit: 12 }))
.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
const anchor = recent[0];
if (!anchor || Date.parse(anchor.updatedAt) < Date.now() - 14 * 86400000) return [];
const segmenter = new Intl.Segmenter("zh", { granularity: "word" });
const terms = [...new Set([...segmenter.segment(anchor.title || anchor.excerpt)]
.filter(part => part.isWordLike && part.segment.length >= 2).map(part => part.segment))].slice(0, 3);
const related = (await Promise.all(terms.map(query => searchMemoSummaries(db, { workspaceId: scope.workspaceId, query, limit: 4 })))).flat();
const ids = [...new Set([anchor.id, ...related.map(note => note.id), ...recent.map(note => note.id)])].slice(0, 12);
const notes: MemoDetail[] = [];
let budget = 12000;
for (const id of ids) {
const note = await getMemoDetail(db, scope.workspaceId, id);
if (!note) continue;
if (!note.contentMarkdown.trim() || note.contentMarkdown.length > Math.min(8000, budget)) {
if (id === anchor.id) return []; // Never propose writes from truncated sources.
continue;
}
notes.push(note); budget -= note.contentMarkdown.length;
if (notes.length === 6) break;
}
return notes;
}
type DiscoverySession = {
generationInput: DiscoveryContextInput;
inputHash: string;
cursor: number;
settingsVersion: number;
memoryRevision: number;
recallEnabled: boolean;
now: string;
};
const discoverySession = (value: unknown): DiscoverySession | null => {
if (!value || typeof value !== "object") return null;
const record = value as Record<string, unknown>;
const generationInput = record.generationInput && typeof record.generationInput === "object"
? record.generationInput as DiscoveryContextInput : null;
if (!generationInput || typeof record.inputHash !== "string" || typeof record.cursor !== "number"
|| typeof record.settingsVersion !== "number" || typeof record.memoryRevision !== "number"
|| typeof record.recallEnabled !== "boolean" || typeof record.now !== "string") return null;
return {
generationInput, inputHash: record.inputHash, cursor: record.cursor, settingsVersion: record.settingsVersion,
memoryRevision: record.memoryRevision, recallEnabled: record.recallEnabled, now: record.now,
};
};
export async function startDiscoveryCheck(db: DatabaseAdapter, scope: CompanionScope, options: {
locale: string; signal: AbortSignal;
loadModelId: () => Promise<string>;
}): Promise<{ turnId: string; generationInput: DiscoveryContextInput; inputHash: string } | null> {
let settings = await settingsRow(db, scope);
if (!settings?.enabled) return null;
await learnCompanionPreferences(db, scope);
await refreshCompanionPreferences(db, scope);
const memoryRevision = await companionRevision(db, scope);
const allMemories = await listCompanionMemories(db, scope, false);
settings = await settingsRow(db, scope);
if (!settings?.enabled) return null;
if (await companionRevision(db, scope) !== memoryRevision) throw changed();
const cursor = await companionWorkspaceCursor(db, scope.workspaceId);
const now = new Date().toISOString();
const turnId = crypto.randomUUID();
const claim = await db.prepare(`UPDATE companion_discovery_settings SET last_check_at = ?, last_cursor = ?, last_memory_revision = ?, last_status = 'running', active_turn_id = ?
WHERE workspace_id = ? AND owner_id = ? AND enabled = 1 AND version = ? AND (last_cursor <> ? OR last_memory_revision <> ?)
AND (last_check_at IS NULL OR last_check_at < ? OR (last_memory_revision <> ? AND last_check_at < ?))`)
.bind(now, cursor, memoryRevision, turnId, ...keys(scope), settings.version, cursor, memoryRevision,
new Date(Date.now() - 86400000).toISOString(), memoryRevision, new Date(Date.now() - 3600000).toISOString()).run();
if (Number(claim.meta.changes) !== 1) return null;
let turn: Awaited<ReturnType<typeof beginCompanionTurn>> | null = null;
const finish = (status: string, inputHash: string | null = null) => db.prepare(`UPDATE companion_discovery_settings SET last_status = ?, active_turn_id = NULL,
last_input_hash = COALESCE(?, last_input_hash)
WHERE workspace_id = ? AND owner_id = ? AND active_turn_id = ?`).bind(status, inputHash, ...keys(scope), turnId).run();
const assertCurrent = async () => {
options.signal.throwIfAborted();
const current = await settingsRow(db, scope);
if (await companionRevision(db, scope) !== memoryRevision || !current?.enabled || current.version !== settings.version || current.active_turn_id !== turnId
|| await companionWorkspaceCursor(db, scope.workspaceId) !== cursor) throw changed();
if (turn && ((await getCompanionTurn(db, scope, turnId))?.status !== "running"
|| await companionRevision(db, scope) !== turn.memory_revision)) throw changed();
};
try {
const candidates = await candidatesFor(db, scope);
if (candidates.length < 1) { await finish("quiet"); return null; }
await assertCurrent();
const memories = settings.recall_enabled ? selectCompanionMemories(applicableMemories(allMemories,
candidates.map(note => note.notebookId), candidates.flatMap(note => note.tags)),
candidates.map(note => `${note.title} ${note.tags.join(" ")} ${note.contentMarkdown.slice(0, 500)}`).join(" ")) : [];
const notebooks = (await db.prepare("SELECT id, name FROM notebooks WHERE workspace_id = ? AND is_deleted = 0 ORDER BY id LIMIT 100")
.bind(scope.workspaceId).all<{ id: string; name: string }>()).results;
const generationInput = {
memories, notebooks,
candidates: candidates.map(note => ({ id: note.id, title: note.title, contentMarkdown: note.contentMarkdown, updatedAt: note.updatedAt, notebookId: note.notebookId, tags: note.tags, plainText: plainText(note.contentJson) })),
anchorId: candidates[0].id, locale: options.locale,
};
const contextRevision = await companionRevision(db, scope);
// Read configuration versions without decrypting credentials/loading SDKs.
// Switching providers or models must not reuse the previous analysis cache.
const modelConfiguration = await db.prepare(`SELECT s.default_model_id, s.updated_at AS settings_updated_at,
p.updated_at AS provider_updated_at, m.updated_at AS model_updated_at
FROM ai_workspace_settings s LEFT JOIN ai_models m ON m.id = s.default_model_id
LEFT JOIN ai_provider_configs p ON p.id = m.provider_config_id AND p.workspace_id = s.workspace_id
WHERE s.workspace_id = ?`).bind(scope.workspaceId).first();
const inputHash = await discoveryInputHash({ ...generationInput, settingsVersion: settings.version, contextRevision, modelConfiguration });
await assertCurrent();
if (inputHash === settings.last_input_hash) { await finish("quiet"); return null; }
const modelId = await options.loadModelId();
turn = await beginCompanionTurn(db, scope, { id: turnId, threadId: turnId, message: "Quiet discovery", useMemory: settings.recall_enabled === 1,
allowNotes: true, locale: companionTurnLocale(options.locale) }, modelId);
const session: DiscoverySession = {
generationInput, inputHash, cursor, settingsVersion: settings.version, memoryRevision,
recallEnabled: settings.recall_enabled === 1, now,
};
await db.prepare("UPDATE companion_turns SET origin = 'discovery', agent_session_json = ? WHERE id = ? AND workspace_id = ? AND owner_id = ?")
.bind(JSON.stringify(session), turnId, ...keys(scope)).run();
await assertCurrent();
return { turnId, generationInput, inputHash };
} catch (error) {
if (turn) await checkpointCompanionTurn(db, scope, turn, "", [], "failed").catch(() => {});
await finish("failed");
throw error;
}
}
export async function completeDiscoveryGeneration(db: DatabaseAdapter, scope: CompanionScope, turnId: string, output: unknown, signal: AbortSignal) {
const turn = await getCompanionTurn(db, scope, turnId);
const session = discoverySession(turn ? JSON.parse(turn.agent_session_json || "{}") : null);
if (!turn || turn.status !== "running" || !session) throw changed();
const finish = (status: string, inputHash: string | null = null) => db.prepare(`UPDATE companion_discovery_settings SET last_status = ?, active_turn_id = NULL,
last_input_hash = COALESCE(?, last_input_hash)
WHERE workspace_id = ? AND owner_id = ? AND active_turn_id = ?`).bind(status, inputHash, ...keys(scope), turnId).run();
const assertCurrent = async () => {
signal.throwIfAborted();
const current = await settingsRow(db, scope);
if (await companionRevision(db, scope) !== session.memoryRevision || !current?.enabled || current.version !== session.settingsVersion
|| current.active_turn_id !== turnId || await companionWorkspaceCursor(db, scope.workspaceId) !== session.cursor) throw changed();
if ((await getCompanionTurn(db, scope, turnId))?.status !== "running"
|| await companionRevision(db, scope) !== turn.memory_revision) throw changed();
};
try {
await assertCurrent();
const parsed = CompanionDiscoveryOutputSchema.parse(output);
const candidateIds = new Set(session.generationInput.candidates.map(note => note.id));
const decoded = parsed.suggestion && parsed.suggestion.sourceIds.every(id => candidateIds.has(id))
? parsed
: discoveryContext(session.generationInput).decode(parsed);
const { suggestion } = decoded;
await assertCurrent();
if (!suggestion) {
await db.prepare("DELETE FROM companion_turns WHERE id = ? AND workspace_id = ? AND owner_id = ?").bind(turnId, ...keys(scope)).run();
await finish("quiet", session.inputHash); return;
}
const candidates: MemoDetail[] = [];
for (const id of candidateIds) {
const note = await getMemoDetail(db, scope.workspaceId, id);
if (!note) throw changed();
candidates.push(note);
}
const memories = session.generationInput.memories ?? [];
const notebooks = session.generationInput.notebooks ?? [];
const sources = suggestion.sourceIds.map(id => candidates.find(note => note.id === id));
if (sources.some(note => !note) || new Set(suggestion.sourceIds).size !== sources.length || !suggestion.sourceIds.includes(candidates[0].id)) throw changed();
const notes = sources as MemoDetail[];
if ((suggestion.memoryIds ?? []).some(id => !memories.some(memory => memory.id === id))) throw changed();
if (["insight", "merge", "append"].includes(suggestion.kind) && notes.length < 2) throw changed();
const allMemories = await listCompanionMemories(db, scope, false);
if (session.recallEnabled && allMemories.some(memory => (!memory.state || memory.state === "active") && notes.some(note => memory.ruleKey === JSON.stringify(["avoid", note.notebookId, suggestion.kind])))) {
await db.prepare("DELETE FROM companion_turns WHERE id = ? AND workspace_id = ? AND owner_id = ?").bind(turnId, ...keys(scope)).run();
await finish("quiet", session.inputHash); return;
}
const fingerprint = `${suggestion.kind}:${[...suggestion.sourceIds].sort().join(":")}${["move", "tag"].includes(suggestion.kind) ? `:${suggestion.notebookId ?? ""}:${JSON.stringify(suggestion.tags ?? [])}` : ""}`;
const duplicate = await db.prepare("SELECT id FROM companion_discoveries WHERE workspace_id = ? AND owner_id = ? AND fingerprint = ?")
.bind(...keys(scope), fingerprint).first();
if (duplicate) {
await db.prepare("DELETE FROM companion_turns WHERE id = ? AND workspace_id = ? AND owner_id = ?").bind(turnId, ...keys(scope)).run();
await finish("quiet", session.inputHash); return;
}
let actionId: string | null = null;
const inspected = new Map(notes.map(note => [note.id, note.revision]));
if (suggestion.kind !== "insight") {
let toolName: string;
let args: Record<string, unknown>;
if (suggestion.kind === "move") {
if (!suggestion.notebookId || !notebooks.some(n => n.id === suggestion.notebookId) || notes.some(n => n.notebookId === suggestion.notebookId)) throw changed();
toolName = "move_memos";
args = { memoIds: notes.map(n => n.id), notebookId: suggestion.notebookId };
} else if (suggestion.kind === "tag") {
if (notes.length !== 1 || !suggestion.tags?.length || suggestion.tags.some(tag => !candidates.some(n => n.tags.includes(tag)))) throw changed();
toolName = "add_tags_to_memos";
args = { memoIds: [notes[0].id], tags: suggestion.tags };
} else if (suggestion.kind === "merge") {
toolName = "merge_memos";
args = { memoIds: notes.map(note => note.id), title: suggestion.title, notebookId: notes[0].notebookId };
} else {
const target = notes.find(note => note.id === suggestion.targetId);
const source = notes.find(note => note.id !== suggestion.targetId);
if (notes.length !== 2 || !target || !source || source.id !== candidates[0].id || !notes.every(note => plainText(note.contentJson))) throw changed();
// Resource associations are not copied by update_memo; defer these cases
// to merge_memos instead of creating broken attachment ownership.
if (await db.prepare("SELECT id FROM resources WHERE memo_id = ? AND is_deleted = 0 LIMIT 1")
.bind(source.id).first()) throw changed();
toolName = "update_memo";
args = { memoId: target.id, contentMarkdown: `${target.contentMarkdown}\n\n---\n\n${source.contentMarkdown}` };
}
actionId = (await proposeCompanionToolAction(db, scope, turnId, toolName, args, suggestion.body, session.cursor, inspected,
notes.map(note => note.id))).proposalId;
}
const sourceRefs = notes.map(note => ({ id: note.id, title: note.title || "", notebookId: note.notebookId, revision: note.revision }));
const id = crypto.randomUUID();
// Publication and turn completion share one transaction. A revoked setting,
// forgotten context or edited note can never become a confirmable proposal.
await db.batch([
db.prepare(`INSERT INTO companion_action_checks(id, valid) VALUES (?, CASE WHEN EXISTS (
SELECT 1 FROM companion_discovery_settings s JOIN companion_turns t ON t.id = s.active_turn_id
JOIN companion_state cs ON cs.workspace_id = s.workspace_id AND cs.owner_id = s.owner_id
WHERE s.workspace_id = ? AND s.owner_id = ? AND s.enabled = 1 AND s.version = ? AND s.active_turn_id = ?
AND t.status = 'running' AND t.memory_revision = cs.memory_revision AND t.expires_at > ?
AND (${workspaceCursorSql}) = ?) THEN 1 ELSE 0 END)`)
.bind(id, ...keys(scope), session.settingsVersion, turnId, new Date().toISOString(), scope.workspaceId, session.cursor),
db.prepare(`INSERT INTO companion_discoveries(id, workspace_id, owner_id, turn_id, action_id, settings_version,
kind, title, body, sources_json, fingerprint, created_at, memory_ids_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
.bind(id, ...keys(scope), turnId, actionId, session.settingsVersion, suggestion.kind, suggestion.title, suggestion.body, JSON.stringify(sourceRefs), fingerprint, session.now, JSON.stringify(suggestion.memoryIds ?? [])),
db.prepare("UPDATE companion_turns SET status = 'completed', response = ?, sources_json = ? WHERE id = ?")
.bind(suggestion.body, JSON.stringify(sourceRefs), turnId),
db.prepare("DELETE FROM companion_action_checks WHERE id = ?").bind(id),
]);
await finish("ready", session.inputHash);
} catch (error) {
await checkpointCompanionTurn(db, scope, turn, "", [], "failed").catch(() => {});
await finish("failed");
throw error;
}
}
export async function checkDiscoveries(db: DatabaseAdapter, scope: CompanionScope, options: {
locale: string; signal: AbortSignal; loadModel: () => Promise<DiscoveryModel>;
generate?: (input: DiscoveryContextInput & { model: DiscoveryModel; signal: AbortSignal }) => Promise<CompanionDiscoveryOutput>;
}) {
let model: Awaited<Promise<DiscoveryModel>> | undefined;
const started = await startDiscoveryCheck(db, scope, {
locale: options.locale, signal: options.signal,
loadModelId: async () => {
model = await options.loadModel();
return model.modelId;
},
});
if (!started || !model) return;
try {
const generate = options.generate;
if (!generate) throw new Error("Discovery generation must run on the client.");
const output = await generate({ ...started.generationInput, model, signal: options.signal });
await completeDiscoveryGeneration(db, scope, started.turnId, output, options.signal);
} catch (error) {
const turn = await getCompanionTurn(db, scope, started.turnId);
if (turn?.status === "running") {
await checkpointCompanionTurn(db, scope, turn, "", [], "failed").catch(() => {});
await db.prepare(`UPDATE companion_discovery_settings SET last_status = 'failed', active_turn_id = NULL
WHERE workspace_id = ? AND owner_id = ? AND active_turn_id = ?`).bind(...keys(scope), started.turnId).run();
}
throw error;
}
}
export const discoveryPreparePayload = (args: {
turnId: string; generationInput: DiscoveryContextInput;
credentials: { provider: "openai-compatible" | "anthropic" | "google"; baseUrl: string; apiKey: string; modelId: string };
}) => {
const context = discoveryContext(args.generationInput);
return {
quiet: false as const,
turnId: args.turnId,
...args.credentials,
instructions: context.instructions,
prompt: context.prompt,
maxOutputTokens: 1200,
};
};
// An explicit feedback button is a user statement, not an inference from dismissal.
export async function rememberDiscoveryFeedback(db: DatabaseAdapter, scope: CompanionScope, id: string) {
const item = (await listDiscoveries(db, scope)).find(item => item.id === id);
if (!item || item.kind === "insight" || !item.action || item.action.status !== "pending") throw changed();
const source = item.sources[0];
const notebook = await db.prepare("SELECT name FROM notebooks WHERE id = ? AND workspace_id = ? AND is_deleted = 0")
.bind(source.notebookId, scope.workspaceId).first<{ name: string }>();
if (!notebook) throw changed();
const content = `Do not suggest ${item.kind} operations for notes in notebook “${notebook.name}”. The user explicitly requested this.`.slice(0, 500);
const previous = (await listCompanionMemories(db, scope)).find(memory => memory.content === content && memory.scopeNotebookId === source.notebookId);
if (!previous) await saveCompanionMemory(db, scope, { content, scopeNotebookId: source.notebookId,
ruleKey: JSON.stringify(["avoid", source.notebookId, item.kind]) });
await acknowledgeDiscovery(db, scope, id, true);
}