@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/features/ai/react/use-document-chat.d.ts

@@ -0,0 +1,32 @@
+import { AgentOp } from "../protocol/agent-ops.js";
+import { AgentScope } from "../agent-ops.js";
+import { AgentOpReviewState } from "../agent-op-review.js";
+import { DocumentChat, DocumentChatGeneration, DocumentChatState, DocumentChatTurn } from "../document-chat-model.js";
+import "../index.js";
+import { Editor } from "@tiptap/core";
+//#region src/features/ai/react/use-document-chat.d.ts
+/**
+ * Document chat state for a component (see `createDocumentChat`): re-renders as the conversation streams in. A running
+ * answer is aborted when the component unmounts; hosts that want the conversation to survive closing keep the
+ * component mounted (hidden). The 429 notice goes to `editor`'s surface (else the app's notifier).
+ */
+export declare function useDocumentChat(editor?: Editor): {
+  getState: () => DocumentChatState;
+  ask: (message: string, editor: Editor, scope: AgentScope | null) => Promise<boolean>;
+  abort: () => void;
+  reset: () => void;
+  decide: (editor: Editor, id: string, accept: boolean) => void;
+  reveal: (editor: Editor, op: AgentOp) => boolean;
+  addGeneration: (generation: DocumentChatGeneration) => void;
+  updateGeneration: (generation: DocumentChatGeneration, patch: Partial<Pick<DocumentChatGeneration, "markdown" | "done">>) => void;
+  removeGeneration: (generation: DocumentChatGeneration) => void;
+  clearError: () => void;
+  messages: readonly DocumentChatTurn[];
+  ops: AgentOpReviewState["ops"];
+  streaming: boolean;
+  error: string | null;
+  /** The underlying model, for flows that act on it (`createAiSidebarFlow`). */
+  model: DocumentChat;
+};
+//#endregion
+//# sourceMappingURL=use-document-chat.d.ts.map

package/dist/features/ai/react/use-document-chat.js

@@ -0,0 +1,43 @@
+import { useEditorContext } from "../../../react/context.js";
+import { useStore } from "../../../react/use-store.js";
+import { createDocumentChat } from "../document-chat-model.js";
+import { modelProfiles } from "../model-profiles.js";
+import { useNotifier } from "../../../react/use-notifier.js";
+import { useEffect, useMemo } from "react";
+//#region src/features/ai/react/use-document-chat.ts
+/**
+* Document chat state for a component (see `createDocumentChat`): re-renders as the conversation streams in. A running
+* answer is aborted when the component unmounts; hosts that want the conversation to survive closing keep the
+* component mounted (hidden). The 429 notice goes to `editor`'s surface (else the app's notifier).
+*/
+function useDocumentChat(editor) {
+	const app = useEditorContext();
+	const notify = useNotifier(editor);
+	const chat = useMemo(() => createDocumentChat({
+		fetch: app.fetch,
+		modelRef: modelProfiles(app).modelRef,
+		notify,
+		t: app.t
+	}), [app, notify]);
+	useEffect(() => () => chat.abort(), [chat]);
+	/** `getState` reads the current state after an await (a render's `state` would be stale). */
+	return {
+		/** The underlying model, for flows that act on it (`createAiSidebarFlow`). */
+		model: chat,
+		...useStore(chat.state),
+		getState: chat.state.get,
+		ask: chat.ask,
+		abort: chat.abort,
+		reset: chat.reset,
+		decide: chat.decide,
+		reveal: chat.reveal,
+		addGeneration: chat.addGeneration,
+		updateGeneration: chat.updateGeneration,
+		removeGeneration: chat.removeGeneration,
+		clearError: chat.clearError
+	};
+}
+//#endregion
+export { useDocumentChat };
+
+//# sourceMappingURL=use-document-chat.js.map

package/dist/features/ai/react/use-document-chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-document-chat.js","names":[],"sources":["../../../../src/features/ai/react/use-document-chat.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport { useEffect, useMemo } from 'react'\nimport { useEditorContext } from '../../../react/context'\nimport { useStore } from '../../../react/use-store'\nimport { createDocumentChat } from '../document-chat-model'\nimport { modelProfiles } from '../model-profiles'\nimport { useNotifier } from '../../../react/use-notifier'\n\n/**\n * Document chat state for a component (see `createDocumentChat`): re-renders as the conversation streams in. A running\n * answer is aborted when the component unmounts; hosts that want the conversation to survive closing keep the\n * component mounted (hidden). The 429 notice goes to `editor`'s surface (else the app's notifier).\n */\nexport function useDocumentChat(editor?: Editor) {\n  const app = useEditorContext()\n  const notify = useNotifier(editor)\n  const chat = useMemo(\n    () => createDocumentChat({ fetch: app.fetch, modelRef: modelProfiles(app).modelRef, notify, t: app.t }),\n    [app, notify],\n  )\n  useEffect(() => () => chat.abort(), [chat])\n  const state = useStore(chat.state)\n  /** `getState` reads the current state after an await (a render's `state` would be stale). */\n  return {\n    /** The underlying model, for flows that act on it (`createAiSidebarFlow`). */\n    model: chat,\n    ...state,\n    getState: chat.state.get,\n    ask: chat.ask,\n    abort: chat.abort,\n    reset: chat.reset,\n    decide: chat.decide,\n    reveal: chat.reveal,\n    addGeneration: chat.addGeneration,\n    updateGeneration: chat.updateGeneration,\n    removeGeneration: chat.removeGeneration,\n    clearError: chat.clearError,\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,gBAAgB,QAAiB;CAC/C,MAAM,MAAM,iBAAiB;CAC7B,MAAM,SAAS,YAAY,MAAM;CACjC,MAAM,OAAO,cACL,mBAAmB;EAAE,OAAO,IAAI;EAAO,UAAU,cAAc,GAAG,CAAC,CAAC;EAAU;EAAQ,GAAG,IAAI;CAAE,CAAC,GACtG,CAAC,KAAK,MAAM,CACd;CACA,sBAAsB,KAAK,MAAM,GAAG,CAAC,IAAI,CAAC;;CAG1C,OAAO;;EAEL,OAAO;EACP,GALY,SAAS,KAAK,KAKnB;EACP,UAAU,KAAK,MAAM;EACrB,KAAK,KAAK;EACV,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,QAAQ,KAAK;EACb,QAAQ,KAAK;EACb,eAAe,KAAK;EACpB,kBAAkB,KAAK;EACvB,kBAAkB,KAAK;EACvB,YAAY,KAAK;CACnB;AACF"}

package/dist/features/ai/react/use-model-profiles.d.ts

@@ -0,0 +1,20 @@
+import { ModelSlot } from "../../../settings/values.js";
+import "../../../settings/index.js";
+import { ModelProfile, ModelRef, UserModelProfile } from "../protocol/models.js";
+import "../protocol/index.js";
+//#region src/features/ai/react/use-model-profiles.d.ts
+/**
+ * Model profiles the AI features run on, shared by all editors of the app (see `modelProfiles`): server presets plus
+ * the user profiles of this browser. Re-renders when either or the settings' slot assignment changes.
+ */
+export declare function useModelProfiles(): {
+  presets: ModelProfile[];
+  userProfiles: UserModelProfile[];
+  profiles: ModelProfile[];
+  slotProfile: (slot: ModelSlot) => ModelProfile | undefined;
+  modelRef: (slot: ModelSlot) => ModelRef;
+  saveUserProfile: (profile: UserModelProfile) => void;
+  removeUserProfile: (id: string) => void;
+};
+//#endregion
+//# sourceMappingURL=use-model-profiles.d.ts.map

package/dist/features/ai/react/use-model-profiles.js

@@ -0,0 +1,33 @@
+import { useEditorContext } from "../../../react/context.js";
+import { useStore } from "../../../react/use-store.js";
+import { modelProfiles } from "../model-profiles.js";
+import { useMemo } from "react";
+//#region src/features/ai/react/use-model-profiles.ts
+/**
+* Model profiles the AI features run on, shared by all editors of the app (see `modelProfiles`): server presets plus
+* the user profiles of this browser. Re-renders when either or the settings' slot assignment changes.
+*/
+function useModelProfiles() {
+	const app = useEditorContext();
+	const model = modelProfiles(app);
+	useStore(app.settings);
+	const presets = useStore(model.presets);
+	const userProfiles = useStore(model.userProfiles);
+	return {
+		presets,
+		userProfiles,
+		profiles: useMemo(() => model.profiles(), [
+			model,
+			presets,
+			userProfiles
+		]),
+		slotProfile: model.slotProfile,
+		modelRef: model.modelRef,
+		saveUserProfile: model.saveUserProfile,
+		removeUserProfile: model.removeUserProfile
+	};
+}
+//#endregion
+export { useModelProfiles };
+
+//# sourceMappingURL=use-model-profiles.js.map

package/dist/features/ai/react/use-model-profiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-model-profiles.js","names":[],"sources":["../../../../src/features/ai/react/use-model-profiles.ts"],"sourcesContent":["import { useMemo } from 'react'\nimport type { ModelSlot } from '../../../settings'\nimport { useEditorContext } from '../../../react/context'\nimport { useStore } from '../../../react/use-store'\nimport { modelProfiles } from '../model-profiles'\nimport type { ModelProfile, ModelRef, UserModelProfile } from '../protocol'\n\n/**\n * Model profiles the AI features run on, shared by all editors of the app (see `modelProfiles`): server presets plus\n * the user profiles of this browser. Re-renders when either or the settings' slot assignment changes.\n */\nexport function useModelProfiles(): {\n  presets: ModelProfile[]\n  userProfiles: UserModelProfile[]\n  profiles: ModelProfile[]\n  slotProfile: (slot: ModelSlot) => ModelProfile | undefined\n  modelRef: (slot: ModelSlot) => ModelRef\n  saveUserProfile: (profile: UserModelProfile) => void\n  removeUserProfile: (id: string) => void\n} {\n  const app = useEditorContext()\n  const model = modelProfiles(app)\n  // `slotProfile`/`modelRef` read the settings' slot assignment: re-render when it changes.\n  useStore(app.settings)\n  const presets = useStore(model.presets)\n  const userProfiles = useStore(model.userProfiles)\n  // `profiles()` is derived from both stores: recomputed when either changed.\n  const profiles = useMemo(() => model.profiles(), [model, presets, userProfiles])\n  return {\n    presets,\n    userProfiles,\n    profiles,\n    slotProfile: model.slotProfile,\n    modelRef: model.modelRef,\n    saveUserProfile: model.saveUserProfile,\n    removeUserProfile: model.removeUserProfile,\n  }\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,mBAQd;CACA,MAAM,MAAM,iBAAiB;CAC7B,MAAM,QAAQ,cAAc,GAAG;CAE/B,SAAS,IAAI,QAAQ;CACrB,MAAM,UAAU,SAAS,MAAM,OAAO;CACtC,MAAM,eAAe,SAAS,MAAM,YAAY;CAGhD,OAAO;EACL;EACA;EACA,UAJe,cAAc,MAAM,SAAS,GAAG;GAAC;GAAO;GAAS;EAAY,CAIrE;EACP,aAAa,MAAM;EACnB,UAAU,MAAM;EAChB,iBAAiB,MAAM;EACvB,mBAAmB,MAAM;CAC3B;AACF"}

package/dist/features/ai/react.d.ts

@@ -0,0 +1,23 @@
+import { ReactFeature } from "../../react/EditorSurface.js";
+import { AiRunBody, AiStatus } from "./assistant.js";
+import "../../react/index.js";
+import { AiReviewBar } from "./react/AiReviewBar.js";
+import { AiSelectionMenu } from "./react/AiSelectionMenu.js";
+import { AiSidebar } from "./react/AiSidebar.js";
+import { DocumentChatAnswer } from "./react/DocumentChatAnswer.js";
+import { DocumentChatOps } from "./react/DocumentChatOps.js";
+import { ModelQuickSwitch } from "./react/ModelQuickSwitch.js";
+import { SettingsAiTab } from "./react/SettingsAiTab.js";
+import { SettingsModelProfiles } from "./react/SettingsModelProfiles.js";
+import { useAiAssistant } from "./react/use-ai-assistant.js";
+import { useDocumentChat } from "./react/use-document-chat.js";
+import { useModelProfiles } from "./react/use-model-profiles.js";
+//#region src/features/ai/react.d.ts
+/**
+ * The React AI feature (shadcn): see `aiFeatureCore`. The host places `AiSidebar` beside the editor (bind the surface's
+ * `sidebarOpen` state to its `open` prop) and may place `ModelQuickSwitch`.
+ */
+export declare function aiFeature(): ReactFeature;
+//#endregion
+export { AiReviewBar, type AiRunBody, AiSelectionMenu, AiSidebar, type AiStatus, DocumentChatAnswer, DocumentChatOps, ModelQuickSwitch, SettingsAiTab, SettingsModelProfiles, useAiAssistant, useDocumentChat, useModelProfiles };
+//# sourceMappingURL=react.d.ts.map

package/dist/features/ai/react.js

@@ -0,0 +1,28 @@
+import { aiFeatureCore } from "./feature.js";
+import { AiReviewBar } from "./react/AiReviewBar.js";
+import { useModelProfiles } from "./react/use-model-profiles.js";
+import { ModelQuickSwitch } from "./react/ModelQuickSwitch.js";
+import { useAiAssistant } from "./react/use-ai-assistant.js";
+import { AiSelectionMenu } from "./react/AiSelectionMenu.js";
+import { SettingsModelProfiles } from "./react/SettingsModelProfiles.js";
+import { SettingsAiTab } from "./react/SettingsAiTab.js";
+import { DocumentChatAnswer } from "./react/DocumentChatAnswer.js";
+import { DocumentChatOps } from "./react/DocumentChatOps.js";
+import { useDocumentChat } from "./react/use-document-chat.js";
+import { AiSidebar } from "./react/AiSidebar.js";
+//#region src/features/ai/react.ts
+/**
+* The React AI feature (shadcn): see `aiFeatureCore`. The host places `AiSidebar` beside the editor (bind the surface's
+* `sidebarOpen` state to its `open` prop) and may place `ModelQuickSwitch`.
+*/
+function aiFeature() {
+	return aiFeatureCore({
+		selectionMenu: AiSelectionMenu,
+		reviewBar: AiReviewBar,
+		settingsTab: SettingsAiTab
+	});
+}
+//#endregion
+export { AiReviewBar, AiSelectionMenu, AiSidebar, DocumentChatAnswer, DocumentChatOps, ModelQuickSwitch, SettingsAiTab, SettingsModelProfiles, aiFeature, useAiAssistant, useDocumentChat, useModelProfiles };
+
+//# sourceMappingURL=react.js.map

package/dist/features/ai/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../../../src/features/ai/react.ts"],"sourcesContent":["import type { ReactFeature } from '../../react'\nimport { aiFeatureCore } from './feature'\nimport { AiReviewBar } from './react/AiReviewBar'\nimport { AiSelectionMenu } from './react/AiSelectionMenu'\nimport { SettingsAiTab } from './react/SettingsAiTab'\n\nexport { AiReviewBar } from './react/AiReviewBar'\nexport { AiSelectionMenu } from './react/AiSelectionMenu'\nexport { AiSidebar } from './react/AiSidebar'\nexport { DocumentChatAnswer } from './react/DocumentChatAnswer'\nexport { DocumentChatOps } from './react/DocumentChatOps'\nexport { ModelQuickSwitch } from './react/ModelQuickSwitch'\nexport { SettingsAiTab } from './react/SettingsAiTab'\nexport { SettingsModelProfiles } from './react/SettingsModelProfiles'\nexport { type AiRunBody, type AiStatus, useAiAssistant } from './react/use-ai-assistant'\nexport { useDocumentChat } from './react/use-document-chat'\nexport { useModelProfiles } from './react/use-model-profiles'\n\n/**\n * The React AI feature (shadcn): see `aiFeatureCore`. The host places `AiSidebar` beside the editor (bind the surface's\n * `sidebarOpen` state to its `open` prop) and may place `ModelQuickSwitch`.\n */\nexport function aiFeature(): ReactFeature {\n  return aiFeatureCore({\n    selectionMenu: AiSelectionMenu,\n    reviewBar: AiReviewBar,\n    settingsTab: SettingsAiTab,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAsBA,SAAgB,YAA0B;CACxC,OAAO,cAAc;EACnB,eAAe;EACf,WAAW;EACX,aAAa;CACf,CAAC;AACH"}

package/dist/features/ai/sidebar-flow.d.ts

@@ -0,0 +1,61 @@
+import { Translate } from "../../i18n/index.js";
+import { Notifier } from "../../core/notify.js";
+import { ReadonlyStore } from "../../core/store.js";
+import { AiTask } from "./protocol/tasks.js";
+import "./protocol/index.js";
+import { AgentScope } from "./agent-ops.js";
+import { AiAssistant } from "./assistant.js";
+import { DocumentChat, DocumentChatGeneration } from "./document-chat-model.js";
+import { Editor } from "@tiptap/core";
+//#region src/features/ai/sidebar-flow.d.ts
+export interface AiSidebarFlowOptions {
+  /** The built-in conversation: its message list also holds the generation turns. Omit with `send` for a host-driven one. */
+  chat?: DocumentChat;
+  /** The host's transport for a question: it receives the question and the selection scope, answers whether it was sent. Takes the place of `chat.ask`. */
+  send?: (question: string, scope: AgentScope | null) => Promise<boolean>;
+  assistant: AiAssistant;
+  notify: Notifier;
+  /** The app's translator (`EditorContext.t`): the notices and the headings of generated results. */
+  t: Translate;
+  /** The current editor, read when a step runs, so a flow that continues after an await sees the latest one. */
+  editor: () => Editor | undefined;
+}
+export interface AiSidebarFlow {
+  /** The block generation streaming right now (a turn in the chat's messages); null while none runs. */
+  running: ReadonlyStore<DocumentChatGeneration | null>;
+  /**
+   * The generation turns the flow keeps itself when it has no `chat` (the chat's messages hold them otherwise, and
+   * this stays empty); each is applied or dropped through `apply`/`drop`.
+   */
+  generations: ReadonlyStore<readonly DocumentChatGeneration[]>;
+  /** An editor is present and neither a chat answer nor a generation streams: one request at a time. */
+  canRun: () => boolean;
+  /**
+   * Asks `question` about the document and selection as they are right now, so follow-ups see edits made since the
+   * last message: through the host's `send` when given, else the chat. Returns false when it was not sent or not
+   * answered, so the caller can restore its input (also without a transport: neither `send` nor `chat`).
+   */
+  send: (question: string) => Promise<boolean>;
+  /**
+   * Runs block generation `task` and streams its result into a new assistant turn, with the apply target captured now
+   * (after the caret's block, or the document's end). Returns false when nothing was kept (error, rate limit, stopped
+   * before any text, or the conversation was reset meanwhile).
+   */
+  generate: (task: AiTask, prompt?: string) => Promise<boolean>;
+  /** „Übernehmen“: inserts a finished generation (or opens its in-document review) and drops its turn. */
+  apply: (generation: DocumentChatGeneration) => void;
+  /** „Verwerfen“ (and the end of an applied or failed run): removes the generation's turn and releases its target. */
+  drop: (generation: DocumentChatGeneration) => void;
+  /** Stops whatever streams and forgets the generations' targets (before the conversation is reset or unmounted). */
+  end: () => void;
+  /** Ends the generations and clears the conversation. */
+  newConversation: () => void;
+}
+/**
+ * The AI sidebar's flow over a document chat and an assistant, shared by both UI surfaces: they only render the
+ * models' state and call this. A host whose conversation runs elsewhere passes `send` (and no `chat`, unless it wants
+ * the chat's message list for the generation turns).
+ */
+export declare function createAiSidebarFlow({ chat, send: host, assistant, notify, t, editor: getEditor }: AiSidebarFlowOptions): AiSidebarFlow;
+//#endregion
+//# sourceMappingURL=sidebar-flow.d.ts.map

package/dist/features/ai/sidebar-flow.js

@@ -0,0 +1,125 @@
+import { aiContextOf } from "../../core/pipeline.js";
+import { createStore } from "../../core/store.js";
+import { releaseRanges } from "../../core/doc-anchors.js";
+import { AI_LIMITS, withTaskHeading } from "./protocol/tasks.js";
+import { selectionScope } from "./agent-ops.js";
+import { aiApplyFailure, applyAiResult, captureTarget, documentMarkdown, formatTaskResult, insertBlocksAtTarget } from "./ai-apply.js";
+//#region src/features/ai/sidebar-flow.ts
+/**
+* The AI sidebar's flow over a document chat and an assistant, shared by both UI surfaces: they only render the
+* models' state and call this. A host whose conversation runs elsewhere passes `send` (and no `chat`, unless it wants
+* the chat's message list for the generation turns).
+*/
+function createAiSidebarFlow({ chat, send: host, assistant, notify, t, editor: getEditor }) {
+	const running = createStore(null);
+	const own = createStore([]);
+	const canRun = () => !!getEditor() && !chat?.state.get().streaming && assistant.state.get().status !== "streaming";
+	function addGeneration(generation) {
+		if (chat) chat.addGeneration(generation);
+		else own.set([...own.get(), generation]);
+	}
+	function updateGeneration(generation, patch) {
+		if (chat) chat.updateGeneration(generation, patch);
+		else {
+			Object.assign(generation, patch);
+			own.set([...own.get()]);
+		}
+	}
+	function removeGeneration(generation) {
+		if (chat) chat.removeGeneration(generation);
+		else own.set(own.get().filter((turn) => turn !== generation));
+	}
+	/** Forgets the anchor of a generation's target (DocAnchors). */
+	function releaseTarget(target) {
+		const editor = getEditor();
+		if (editor && !editor.isDestroyed && target.mode !== "append-to-document") releaseRanges(editor, [target.anchor]);
+	}
+	function drop(generation) {
+		releaseTarget(generation.target);
+		removeGeneration(generation);
+	}
+	async function send(question) {
+		const editor = getEditor();
+		if (!editor || !canRun()) return false;
+		assistant.clearError();
+		const scope = selectionScope(editor.state);
+		if (host) return host(question, scope);
+		return chat ? chat.ask(question, editor, scope) : false;
+	}
+	async function generate(task, prompt = "") {
+		const editor = getEditor();
+		if (!editor || !canRun() || task.needsPrompt && !prompt) return false;
+		const { blocks } = aiContextOf(editor);
+		chat?.clearError();
+		const generation = {
+			task,
+			prompt,
+			markdown: "",
+			target: captureTarget(editor, task.apply),
+			done: false
+		};
+		addGeneration(generation);
+		running.set(generation);
+		await assistant.run({
+			task: task.id,
+			prompt,
+			selection: "",
+			context: documentMarkdown(editor, task.wholeDocument ? AI_LIMITS.transcript : AI_LIMITS.context),
+			blocks
+		});
+		if (running.get() !== generation) return false;
+		running.set(null);
+		const { output, status } = assistant.state.get();
+		updateGeneration(generation, {
+			markdown: output,
+			done: status === "done"
+		});
+		if (output) return true;
+		drop(generation);
+		return false;
+	}
+	function apply(generation) {
+		const editor = getEditor();
+		if (!editor || !generation.done || !generation.markdown) return;
+		if (generation.target.mode === "replace-selection") {
+			const outcome = applyAiResult(editor, "replace", generation.target.anchor, withTaskHeading(generation.task, generation.markdown, t));
+			if (outcome !== "ok") {
+				notify(aiApplyFailure(outcome, t));
+				if (outcome !== "unchanged") return;
+			}
+		} else if (!insertBlocksAtTarget(editor, generation.target, formatTaskResult(editor, generation.task, generation.markdown, t))) {
+			notify({
+				title: t("ai.apply.missing.title"),
+				kind: "error"
+			});
+			return;
+		}
+		drop(generation);
+	}
+	function end() {
+		running.set(null);
+		assistant.reset();
+		const turns = chat ? chat.state.get().messages.flatMap((turn) => turn.role === "assistant" && turn.generation ? [turn.generation] : []) : own.get();
+		for (const generation of turns) releaseTarget(generation.target);
+	}
+	function newConversation() {
+		end();
+		if (chat) chat.reset();
+		else own.set([]);
+	}
+	return {
+		running,
+		generations: own,
+		canRun,
+		send,
+		generate,
+		apply,
+		drop,
+		end,
+		newConversation
+	};
+}
+//#endregion
+export { createAiSidebarFlow };
+
+//# sourceMappingURL=sidebar-flow.js.map

package/dist/features/ai/sidebar-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidebar-flow.js","names":[],"sources":["../../../src/features/ai/sidebar-flow.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport { aiContextOf, releaseRanges } from '../../core'\nimport type { Notifier } from '../../core/notify'\nimport { createStore, type ReadonlyStore } from '../../core/store'\nimport type { Translate } from '../../i18n'\nimport { type AgentScope, selectionScope } from './agent-ops'\nimport { aiApplyFailure, type AiTarget, applyAiResult, captureTarget, documentMarkdown, formatTaskResult, insertBlocksAtTarget } from './ai-apply'\nimport type { AiAssistant } from './assistant'\nimport type { DocumentChat, DocumentChatGeneration } from './document-chat-model'\nimport { AI_LIMITS, type AiTask, withTaskHeading } from './protocol'\n\nexport interface AiSidebarFlowOptions {\n  /** The built-in conversation: its message list also holds the generation turns. Omit with `send` for a host-driven one. */\n  chat?: DocumentChat\n  /** The host's transport for a question: it receives the question and the selection scope, answers whether it was sent. Takes the place of `chat.ask`. */\n  send?: (question: string, scope: AgentScope | null) => Promise<boolean>\n  assistant: AiAssistant\n  notify: Notifier\n  /** The app's translator (`EditorContext.t`): the notices and the headings of generated results. */\n  t: Translate\n  /** The current editor, read when a step runs, so a flow that continues after an await sees the latest one. */\n  editor: () => Editor | undefined\n}\n\nexport interface AiSidebarFlow {\n  /** The block generation streaming right now (a turn in the chat's messages); null while none runs. */\n  running: ReadonlyStore<DocumentChatGeneration | null>\n  /**\n   * The generation turns the flow keeps itself when it has no `chat` (the chat's messages hold them otherwise, and\n   * this stays empty); each is applied or dropped through `apply`/`drop`.\n   */\n  generations: ReadonlyStore<readonly DocumentChatGeneration[]>\n  /** An editor is present and neither a chat answer nor a generation streams: one request at a time. */\n  canRun: () => boolean\n  /**\n   * Asks `question` about the document and selection as they are right now, so follow-ups see edits made since the\n   * last message: through the host's `send` when given, else the chat. Returns false when it was not sent or not\n   * answered, so the caller can restore its input (also without a transport: neither `send` nor `chat`).\n   */\n  send: (question: string) => Promise<boolean>\n  /**\n   * Runs block generation `task` and streams its result into a new assistant turn, with the apply target captured now\n   * (after the caret's block, or the document's end). Returns false when nothing was kept (error, rate limit, stopped\n   * before any text, or the conversation was reset meanwhile).\n   */\n  generate: (task: AiTask, prompt?: string) => Promise<boolean>\n  /** „Übernehmen“: inserts a finished generation (or opens its in-document review) and drops its turn. */\n  apply: (generation: DocumentChatGeneration) => void\n  /** „Verwerfen“ (and the end of an applied or failed run): removes the generation's turn and releases its target. */\n  drop: (generation: DocumentChatGeneration) => void\n  /** Stops whatever streams and forgets the generations' targets (before the conversation is reset or unmounted). */\n  end: () => void\n  /** Ends the generations and clears the conversation. */\n  newConversation: () => void\n}\n\n/**\n * The AI sidebar's flow over a document chat and an assistant, shared by both UI surfaces: they only render the\n * models' state and call this. A host whose conversation runs elsewhere passes `send` (and no `chat`, unless it wants\n * the chat's message list for the generation turns).\n */\nexport function createAiSidebarFlow({ chat, send: host, assistant, notify, t, editor: getEditor }: AiSidebarFlowOptions): AiSidebarFlow {\n  const running = createStore<DocumentChatGeneration | null>(null)\n  // Where the generation turns live without a chat.\n  const own = createStore<readonly DocumentChatGeneration[]>([])\n\n  const canRun = () => !!getEditor() && !chat?.state.get().streaming && assistant.state.get().status !== 'streaming'\n\n  function addGeneration(generation: DocumentChatGeneration) {\n    if (chat) chat.addGeneration(generation)\n    else own.set([...own.get(), generation])\n  }\n\n  function updateGeneration(generation: DocumentChatGeneration, patch: Partial<Pick<DocumentChatGeneration, 'markdown' | 'done'>>) {\n    if (chat) chat.updateGeneration(generation, patch)\n    else {\n      Object.assign(generation, patch)\n      own.set([...own.get()])\n    }\n  }\n\n  function removeGeneration(generation: DocumentChatGeneration) {\n    if (chat) chat.removeGeneration(generation)\n    else own.set(own.get().filter(turn => turn !== generation))\n  }\n\n  /** Forgets the anchor of a generation's target (DocAnchors). */\n  function releaseTarget(target: AiTarget) {\n    const editor = getEditor()\n    if (editor && !editor.isDestroyed && target.mode !== 'append-to-document') releaseRanges(editor, [target.anchor])\n  }\n\n  function drop(generation: DocumentChatGeneration) {\n    releaseTarget(generation.target)\n    removeGeneration(generation)\n  }\n\n  async function send(question: string): Promise<boolean> {\n    const editor = getEditor()\n    if (!editor || !canRun()) return false\n    assistant.clearError()\n    const scope = selectionScope(editor.state)\n    if (host) return host(question, scope)\n    return chat ? chat.ask(question, editor, scope) : false\n  }\n\n  async function generate(task: AiTask, prompt = ''): Promise<boolean> {\n    const editor = getEditor()\n    if (!editor || !canRun() || (task.needsPrompt && !prompt)) return false\n    // Read before any state changes: a merge error in the editor's `aiContext` throws here and must not leave a turn running.\n    const { blocks } = aiContextOf(editor)\n    chat?.clearError()\n    const generation: DocumentChatGeneration = { task, prompt, markdown: '', target: captureTarget(editor, task.apply), done: false }\n    addGeneration(generation)\n    running.set(generation)\n    await assistant.run({\n      task: task.id,\n      prompt,\n      selection: '',\n      context: documentMarkdown(editor, task.wholeDocument ? AI_LIMITS.transcript : AI_LIMITS.context),\n      blocks,\n    })\n    if (running.get() !== generation) return false // the conversation was reset meanwhile\n    running.set(null)\n    const { output, status } = assistant.state.get()\n    updateGeneration(generation, { markdown: output, done: status === 'done' })\n    // A partial result (error, stopped) stays visible but can only be discarded.\n    if (output) return true\n    drop(generation)\n    return false\n  }\n\n  function apply(generation: DocumentChatGeneration) {\n    const editor = getEditor()\n    if (!editor || !generation.done || !generation.markdown) return\n    if (generation.target.mode === 'replace-selection') {\n      // Opens the in-document review (AiReviewBar): the rewrite is written only once accepted there.\n      const outcome = applyAiResult(editor, 'replace', generation.target.anchor, withTaskHeading(generation.task, generation.markdown, t))\n      if (outcome !== 'ok') {\n        notify(aiApplyFailure(outcome, t))\n        if (outcome !== 'unchanged') return\n      }\n    }\n    // New blocks: a task with a `heading` goes in titled with it — as the `##` heading, or the way the\n    // editor's `formatAiResult` contributor formats it; `insertBlocksAtTarget` normalizes the rest.\n    else if (!insertBlocksAtTarget(editor, generation.target, formatTaskResult(editor, generation.task, generation.markdown, t))) {\n      notify({ title: t('ai.apply.missing.title'), kind: 'error' })\n      return\n    }\n    drop(generation)\n  }\n\n  function end() {\n    running.set(null)\n    assistant.reset()\n    const turns = chat ? chat.state.get().messages.flatMap(turn => turn.role === 'assistant' && turn.generation ? [turn.generation] : []) : own.get()\n    for (const generation of turns) releaseTarget(generation.target)\n  }\n\n  function newConversation() {\n    end()\n    if (chat) chat.reset()\n    else own.set([])\n  }\n\n  return { running, generations: own, canRun, send, generate, apply, drop, end, newConversation }\n}\n"],"mappings":"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"}

package/dist/features/ai/use-ai-assistant.d.ts

@@ -0,0 +1,22 @@
+import { AiAssistant, AiRunBody, AiStatus } from "./assistant.js";
+import { MaybeRefOrGetter } from "vue";
+import { Editor } from "@tiptap/core";
+//#region src/features/ai/use-ai-assistant.d.ts
+/**
+ * Streams `/api/ai/generate` into Vue refs on the task's model slot: a thin hook over `createAiAssistant`. Call it
+ * during component setup (it injects the editor context); the request stops with the component's scope. The 429 notice
+ * goes to `editor`'s surface (else the app's notifier).
+ */
+export declare function useAiAssistant(editor?: MaybeRefOrGetter<Editor | undefined>): {
+  /** The underlying model, for flows that act on it (`createAiSidebarFlow`). */
+  model: AiAssistant;
+  status: import("vue").ComputedRef<AiStatus>;
+  output: import("vue").ComputedRef<string>;
+  error: import("vue").ComputedRef<string | null>;
+  run: (body: AiRunBody) => Promise<void>;
+  abort: () => void;
+  reset: () => void;
+  clearError: () => void;
+};
+//#endregion
+//# sourceMappingURL=use-ai-assistant.d.ts.map

package/dist/features/ai/use-ai-assistant.js

@@ -0,0 +1,39 @@
+import { useEditorContext } from "../../vue/context.js";
+import { createAiAssistant } from "./assistant.js";
+import { modelProfiles } from "./model-profiles.js";
+import { useNotifier } from "../../vue/use-notifier.js";
+import { useStoreRef } from "../../vue/store-ref.js";
+import { computed, getCurrentScope, onScopeDispose } from "vue";
+//#region src/features/ai/use-ai-assistant.ts
+/**
+* Streams `/api/ai/generate` into Vue refs on the task's model slot: a thin hook over `createAiAssistant`. Call it
+* during component setup (it injects the editor context); the request stops with the component's scope. The 429 notice
+* goes to `editor`'s surface (else the app's notifier).
+*/
+function useAiAssistant(editor) {
+	const context = useEditorContext();
+	const assistant = createAiAssistant({
+		fetch: context.fetch,
+		modelRef: modelProfiles(context).modelRef,
+		notify: useNotifier(editor),
+		t: context.t
+	});
+	const snapshot = useStoreRef(assistant.state);
+	if (getCurrentScope()) onScopeDispose(assistant.abort);
+	const { run, abort, reset, clearError } = assistant;
+	return {
+		/** The underlying model, for flows that act on it (`createAiSidebarFlow`). */
+		model: assistant,
+		status: computed(() => snapshot.value.status),
+		output: computed(() => snapshot.value.output),
+		error: computed(() => snapshot.value.error),
+		run,
+		abort,
+		reset,
+		clearError
+	};
+}
+//#endregion
+export { useAiAssistant };
+
+//# sourceMappingURL=use-ai-assistant.js.map

package/dist/features/ai/use-ai-assistant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-ai-assistant.js","names":[],"sources":["../../../src/features/ai/use-ai-assistant.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport { computed, getCurrentScope, type MaybeRefOrGetter, onScopeDispose } from 'vue'\nimport { useEditorContext } from '../../vue/context'\nimport { useStoreRef } from '../../vue/store-ref'\nimport { useNotifier } from '../../vue/use-notifier'\nimport { createAiAssistant } from './assistant'\nimport { modelProfiles } from './model-profiles'\n\nexport type { AiRunBody, AiStatus } from './assistant'\n\n/**\n * Streams `/api/ai/generate` into Vue refs on the task's model slot: a thin hook over `createAiAssistant`. Call it\n * during component setup (it injects the editor context); the request stops with the component's scope. The 429 notice\n * goes to `editor`'s surface (else the app's notifier).\n */\nexport function useAiAssistant(editor?: MaybeRefOrGetter<Editor | undefined>) {\n  const context = useEditorContext()\n  const assistant = createAiAssistant({ fetch: context.fetch, modelRef: modelProfiles(context).modelRef, notify: useNotifier(editor), t: context.t })\n  const snapshot = useStoreRef(assistant.state)\n  if (getCurrentScope()) onScopeDispose(assistant.abort)\n  const { run, abort, reset, clearError } = assistant\n  return {\n    /** The underlying model, for flows that act on it (`createAiSidebarFlow`). */\n    model: assistant,\n    status: computed(() => snapshot.value.status),\n    output: computed(() => snapshot.value.output),\n    error: computed(() => snapshot.value.error),\n    run,\n    abort,\n    reset,\n    clearError,\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,eAAe,QAA+C;CAC5E,MAAM,UAAU,iBAAiB;CACjC,MAAM,YAAY,kBAAkB;EAAE,OAAO,QAAQ;EAAO,UAAU,cAAc,OAAO,CAAC,CAAC;EAAU,QAAQ,YAAY,MAAM;EAAG,GAAG,QAAQ;CAAE,CAAC;CAClJ,MAAM,WAAW,YAAY,UAAU,KAAK;CAC5C,IAAI,gBAAgB,GAAG,eAAe,UAAU,KAAK;CACrD,MAAM,EAAE,KAAK,OAAO,OAAO,eAAe;CAC1C,OAAO;;EAEL,OAAO;EACP,QAAQ,eAAe,SAAS,MAAM,MAAM;EAC5C,QAAQ,eAAe,SAAS,MAAM,MAAM;EAC5C,OAAO,eAAe,SAAS,MAAM,KAAK;EAC1C;EACA;EACA;EACA;CACF;AACF"}

package/dist/features/ai/use-document-chat.d.ts

@@ -0,0 +1,33 @@
+import { AgentOp } from "./protocol/agent-ops.js";
+import "./protocol/index.js";
+import { AgentScope } from "./agent-ops.js";
+import { AgentOpState } from "./agent-op-review.js";
+import { DocumentChat, DocumentChatGeneration, DocumentChatTurn } from "./document-chat-model.js";
+import { MaybeRefOrGetter } from "vue";
+import { Editor } from "@tiptap/core";
+//#region src/features/ai/use-document-chat.d.ts
+/**
+ * The document chat (see `createDocumentChat`) as Vue refs: a thin hook. Call it during component setup (it injects
+ * the editor context); the request stops with the component's scope. The 429 notice goes to `editor`'s surface (else
+ * the app's notifier).
+ */
+export declare function useDocumentChat(editor?: MaybeRefOrGetter<Editor | undefined>): {
+  /** The underlying model, for flows that act on it (`createAiSidebarFlow`). */
+  model: DocumentChat;
+  messages: import("vue").ComputedRef<readonly DocumentChatTurn[]>;
+  ops: import("vue").ComputedRef<Readonly<Record<string, AgentOpState>>>;
+  streaming: import("vue").ComputedRef<boolean>;
+  error: import("vue").ComputedRef<string | null>;
+  ask: (message: string, editor: Editor, scope: AgentScope | null) => Promise<boolean>;
+  abort: () => void;
+  reset: () => void;
+  decide: (editor: Editor, id: string, accept: boolean) => void;
+  reveal: (editor: Editor, op: AgentOp) => boolean;
+  addGeneration: (generation: DocumentChatGeneration) => void;
+  updateGeneration: (generation: DocumentChatGeneration, patch: Partial<Pick<DocumentChatGeneration, "markdown" | "done">>) => void;
+  removeGeneration: (generation: DocumentChatGeneration) => void;
+  clearError: () => void;
+};
+//#endregion
+export type { AgentOpState };
+//# sourceMappingURL=use-document-chat.d.ts.map

package/dist/features/ai/use-document-chat.js

@@ -0,0 +1,45 @@
+import { useEditorContext } from "../../vue/context.js";
+import { createDocumentChat } from "./document-chat-model.js";
+import { modelProfiles } from "./model-profiles.js";
+import { useNotifier } from "../../vue/use-notifier.js";
+import { useStoreRef } from "../../vue/store-ref.js";
+import { computed, getCurrentScope, onScopeDispose } from "vue";
+//#region src/features/ai/use-document-chat.ts
+/**
+* The document chat (see `createDocumentChat`) as Vue refs: a thin hook. Call it during component setup (it injects
+* the editor context); the request stops with the component's scope. The 429 notice goes to `editor`'s surface (else
+* the app's notifier).
+*/
+function useDocumentChat(editor) {
+	const context = useEditorContext();
+	const chat = createDocumentChat({
+		fetch: context.fetch,
+		modelRef: modelProfiles(context).modelRef,
+		notify: useNotifier(editor),
+		t: context.t
+	});
+	const snapshot = useStoreRef(chat.state);
+	if (getCurrentScope()) onScopeDispose(chat.abort);
+	const { ask, abort, reset, decide, reveal, addGeneration, updateGeneration, removeGeneration, clearError } = chat;
+	return {
+		/** The underlying model, for flows that act on it (`createAiSidebarFlow`). */
+		model: chat,
+		messages: computed(() => snapshot.value.messages),
+		ops: computed(() => snapshot.value.ops),
+		streaming: computed(() => snapshot.value.streaming),
+		error: computed(() => snapshot.value.error),
+		ask,
+		abort,
+		reset,
+		decide,
+		reveal,
+		addGeneration,
+		updateGeneration,
+		removeGeneration,
+		clearError
+	};
+}
+//#endregion
+export { useDocumentChat };
+
+//# sourceMappingURL=use-document-chat.js.map

package/dist/features/ai/use-document-chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-document-chat.js","names":[],"sources":["../../../src/features/ai/use-document-chat.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport { computed, getCurrentScope, type MaybeRefOrGetter, onScopeDispose } from 'vue'\nimport { useEditorContext } from '../../vue/context'\nimport { useStoreRef } from '../../vue/store-ref'\nimport { useNotifier } from '../../vue/use-notifier'\nimport { createDocumentChat } from './document-chat-model'\nimport { modelProfiles } from './model-profiles'\n\nexport type { AgentOpState } from './agent-op-review'\nexport type { DocumentChatGeneration, DocumentChatTurn } from './document-chat-model'\n\n/**\n * The document chat (see `createDocumentChat`) as Vue refs: a thin hook. Call it during component setup (it injects\n * the editor context); the request stops with the component's scope. The 429 notice goes to `editor`'s surface (else\n * the app's notifier).\n */\nexport function useDocumentChat(editor?: MaybeRefOrGetter<Editor | undefined>) {\n  const context = useEditorContext()\n  const chat = createDocumentChat({ fetch: context.fetch, modelRef: modelProfiles(context).modelRef, notify: useNotifier(editor), t: context.t })\n  const snapshot = useStoreRef(chat.state)\n  if (getCurrentScope()) onScopeDispose(chat.abort)\n  const { ask, abort, reset, decide, reveal, addGeneration, updateGeneration, removeGeneration, clearError } = chat\n  return {\n    /** The underlying model, for flows that act on it (`createAiSidebarFlow`). */\n    model: chat,\n    messages: computed(() => snapshot.value.messages),\n    ops: computed(() => snapshot.value.ops),\n    streaming: computed(() => snapshot.value.streaming),\n    error: computed(() => snapshot.value.error),\n    ask,\n    abort,\n    reset,\n    decide,\n    reveal,\n    addGeneration,\n    updateGeneration,\n    removeGeneration,\n    clearError,\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,gBAAgB,QAA+C;CAC7E,MAAM,UAAU,iBAAiB;CACjC,MAAM,OAAO,mBAAmB;EAAE,OAAO,QAAQ;EAAO,UAAU,cAAc,OAAO,CAAC,CAAC;EAAU,QAAQ,YAAY,MAAM;EAAG,GAAG,QAAQ;CAAE,CAAC;CAC9I,MAAM,WAAW,YAAY,KAAK,KAAK;CACvC,IAAI,gBAAgB,GAAG,eAAe,KAAK,KAAK;CAChD,MAAM,EAAE,KAAK,OAAO,OAAO,QAAQ,QAAQ,eAAe,kBAAkB,kBAAkB,eAAe;CAC7G,OAAO;;EAEL,OAAO;EACP,UAAU,eAAe,SAAS,MAAM,QAAQ;EAChD,KAAK,eAAe,SAAS,MAAM,GAAG;EACtC,WAAW,eAAe,SAAS,MAAM,SAAS;EAClD,OAAO,eAAe,SAAS,MAAM,KAAK;EAC1C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF"}

package/dist/features/ai/use-model-profiles.d.ts

@@ -0,0 +1,23 @@
+import { ModelSlot } from "../../settings/values.js";
+import "../../settings/index.js";
+import { ModelProfile, ModelRef, UserModelProfile } from "./protocol/models.js";
+import "./protocol/index.js";
+import { ComputedRef, Ref } from "vue";
+//#region src/features/ai/use-model-profiles.d.ts
+/**
+ * Model profiles the AI features run on, as Vue refs: a thin hook over the app's `modelProfiles` model (see there for
+ * the sources). `slotProfile`/`modelRef` read the slot settings, so calling them inside `computed`/templates tracks
+ * both the profiles and the settings. Call it during component setup (it injects the app's editor context); the returned
+ * functions work anywhere afterwards.
+ */
+export declare function useModelProfiles(): {
+  presets: Readonly<Ref<ModelProfile[]>>;
+  userProfiles: Readonly<Ref<UserModelProfile[]>>;
+  profiles: ComputedRef<ModelProfile[]>;
+  slotProfile: (slot: ModelSlot) => ModelProfile | undefined;
+  modelRef: (slot: ModelSlot) => ModelRef;
+  saveUserProfile: (profile: UserModelProfile) => void;
+  removeUserProfile: (id: string) => void;
+};
+//#endregion
+//# sourceMappingURL=use-model-profiles.d.ts.map