@freecallai/pro 0.0.1 → 0.0.3

package/dist/types/navigation/FkpNavigation.vue.d.ts

@@ -0,0 +1,51 @@
+import { ProNavItem, ProNavGroup } from './types';
+type __VLS_Props = {
+    products: ProNavItem[];
+    groups?: ProNavGroup[];
+    productOrder?: string[];
+    selectedKey?: string;
+    collapsed?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'product-icon'?(_: {
+            item: any;
+        }): any;
+        'product-icon'?(_: {
+            item: ProNavItem;
+        }): any;
+        'product-icon'?(_: {
+            item: ProNavItem;
+        }): any;
+    };
+    refs: {
+        editButton: HTMLButtonElement;
+    };
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    open: (key: string, item: ProNavItem) => any;
+    select: (key: string) => any;
+    "update:productOrder": (order: string[]) => any;
+    orderChange: (order: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onOpen?: ((key: string, item: ProNavItem) => any) | undefined;
+    onSelect?: ((key: string) => any) | undefined;
+    "onUpdate:productOrder"?: ((order: string[]) => any) | undefined;
+    onOrderChange?: ((order: string[]) => any) | undefined;
+}>, {
+    groups: ProNavGroup[];
+    productOrder: string[];
+    collapsed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    editButton: HTMLButtonElement;
+}, HTMLElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FkpNavigation } from './FkpNavigation.vue';
+export type { ProNavItem, ProNavGroup } from './types';

package/dist/types/navigation/types.d.ts

@@ -0,0 +1,15 @@
+import { FkpIconName } from '@freecallai/icons';
+export interface ProNavItem {
+    key: string;
+    label: string;
+    icon?: FkpIconName;
+    iconUrl?: string;
+    disabled?: boolean;
+    /** Show a hover affordance and emit open instead of select. The host owns navigation. */
+    opensInNewTab?: boolean;
+}
+export interface ProNavGroup extends ProNavItem {
+    children: ProNavItem[];
+}
+/** Ignore stale/duplicate saved keys and append newly authorized products. */
+export declare function resolveProductOrder(products: ProNavItem[], order: string[]): ProNavItem[];

package/dist/types/rich-text/FkpRichText.vue.d.ts

@@ -2,39 +2,47 @@ import { JSONContent } from '@tiptap/core';
 import { ChoiceTokenKind } from './model/node-contract';
 import { MediaTarget } from './runtime/media-target';
 import { PluginPlan } from './runtime/operations';
-import { CapabilityId, ChangeMeta, EditorDiagnostic, FkpRichTextProps, KnowledgeSceneV1 } from './public/types';
+import { CapabilityId, AddKnowledgeSceneRequest, ChangeMeta, EditorDiagnostic, FkpRichTextProps, RichTextInsertInput, RichTextInsertResult, KnowledgeSceneV1 } from './public/types';
 declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
     undoTypeSwitch(): boolean;
+    insertContent(input: RichTextInsertInput): Promise<RichTextInsertResult>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    delete: () => any;
+    change: (scene: KnowledgeSceneV1, meta: ChangeMeta) => any;
     help: (request: {
         capabilityId: CapabilityId;
     }) => any;
-    change: (scene: KnowledgeSceneV1, meta: ChangeMeta) => any;
     "update:modelValue": (scene: KnowledgeSceneV1) => any;
     diagnostic: (issue: EditorDiagnostic) => any;
     "busy-change": (busy: {
         uploading: number;
         requesting: number;
     }) => any;
+    configure: (request: {
+        capabilityId: "agentSelect" | "tagged";
+    }) => any;
+    "add-scene": (request: AddKnowledgeSceneRequest) => any;
 }, string, import('vue').PublicProps, Readonly<FkpRichTextProps> & Readonly<{
-    onDelete?: (() => any) | undefined;
+    onChange?: ((scene: KnowledgeSceneV1, meta: ChangeMeta) => any) | undefined;
     onHelp?: ((request: {
         capabilityId: CapabilityId;
     }) => any) | undefined;
-    onChange?: ((scene: KnowledgeSceneV1, meta: ChangeMeta) => any) | undefined;
     "onUpdate:modelValue"?: ((scene: KnowledgeSceneV1) => any) | undefined;
     onDiagnostic?: ((issue: EditorDiagnostic) => any) | undefined;
     "onBusy-change"?: ((busy: {
         uploading: number;
         requesting: number;
     }) => any) | undefined;
+    onConfigure?: ((request: {
+        capabilityId: "agentSelect" | "tagged";
+    }) => any) | undefined;
+    "onAdd-scene"?: ((request: AddKnowledgeSceneRequest) => any) | undefined;
 }>, {
     readonly: boolean;
     disabled: boolean;
     sceneKey: string;
     modelValue: KnowledgeSceneV1;
     ackRevision: number;
+    typeSelectionMode: "switch" | "add";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     sceneRoot: HTMLElement;
     toolbar: HTMLDivElement;
@@ -46,6 +54,7 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
         placeholder?: string;
         referencePlaceholder?: boolean;
         schemaPlan: import('./runtime/schema-plan').KnowledgeSchemaPlan;
+        pasteCapabilities?: readonly import('./runtime/knowledge-clipboard').PasteCapability[];
         activeChoiceId?: string | null;
     }> & Readonly<{
         "onUpdate:modelValue"?: ((value: JSONContent) => any) | undefined;
@@ -67,6 +76,7 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
         }) => any) | undefined;
         "onLeave-choice"?: (() => any) | undefined;
     }>, {
+        pasteClipboardContent: (event: ClipboardEvent) => MediaTarget | null;
         isSelectionInsideOriginalReply: () => boolean;
         insertToken: (kind: string, key: string, label: string, token?: string) => void;
         insertOriginal: () => void;
@@ -78,8 +88,12 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
             url: string;
             kind: "image" | "video";
             posterUrl?: string;
-        }, name: string, target?: MediaTarget) => boolean;
+        }, name: string, target: MediaTarget, refocus: boolean) => JSONContent | null;
         insertPendingMedia: (file: File, kind: "image" | "video", target: MediaTarget) => string | null;
+        insertPendingMediaBatch: (files: Array<{
+            file: File;
+            kind: "image" | "video";
+        }>, target: MediaTarget) => string[] | null;
         applyNodeUpdate: (plan: Extract<PluginPlan, {
             kind: "updateNode";
         }>, owner: "image" | "video") => boolean;
@@ -121,6 +135,8 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
             focused: boolean;
         } | null>) => void;
         captureMediaTarget: () => MediaTarget | null;
+        whenReady: () => Promise<boolean>;
+        captureEndTarget: () => MediaTarget | null;
         captureMediaTargetAt: (clientX: number, clientY: number) => MediaTarget | null;
         focus: () => boolean | undefined;
         getJSON: () => import('@tiptap/core').DocumentType<Record<string, any> | undefined, import('@tiptap/core').NodeType<string, Record<string, any> | undefined, any, (import('@tiptap/core').NodeType<any, any, any, any> | import('@tiptap/core').TextType<import('@tiptap/core').MarkType<any, any>>)[]>[]> | undefined;
@@ -158,6 +174,7 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
         placeholder?: string;
         referencePlaceholder?: boolean;
         schemaPlan: import('./runtime/schema-plan').KnowledgeSchemaPlan;
+        pasteCapabilities?: readonly import('./runtime/knowledge-clipboard').PasteCapability[];
         activeChoiceId?: string | null;
     }> & Readonly<{
         "onUpdate:modelValue"?: ((value: JSONContent) => any) | undefined;
@@ -179,6 +196,7 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
         }) => any) | undefined;
         "onLeave-choice"?: (() => any) | undefined;
     }>, {
+        pasteClipboardContent: (event: ClipboardEvent) => MediaTarget | null;
         isSelectionInsideOriginalReply: () => boolean;
         insertToken: (kind: string, key: string, label: string, token?: string) => void;
         insertOriginal: () => void;
@@ -190,8 +208,12 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
             url: string;
             kind: "image" | "video";
             posterUrl?: string;
-        }, name: string, target?: MediaTarget) => boolean;
+        }, name: string, target: MediaTarget, refocus: boolean) => JSONContent | null;
         insertPendingMedia: (file: File, kind: "image" | "video", target: MediaTarget) => string | null;
+        insertPendingMediaBatch: (files: Array<{
+            file: File;
+            kind: "image" | "video";
+        }>, target: MediaTarget) => string[] | null;
         applyNodeUpdate: (plan: Extract<PluginPlan, {
             kind: "updateNode";
         }>, owner: "image" | "video") => boolean;
@@ -233,6 +255,8 @@ declare const _default: import('vue').DefineComponent<FkpRichTextProps, {
             focused: boolean;
         } | null>) => void;
         captureMediaTarget: () => MediaTarget | null;
+        whenReady: () => Promise<boolean>;
+        captureEndTarget: () => MediaTarget | null;
         captureMediaTargetAt: (clientX: number, clientY: number) => MediaTarget | null;
         focus: () => boolean | undefined;
         getJSON: () => import('@tiptap/core').DocumentType<Record<string, any> | undefined, import('@tiptap/core').NodeType<string, Record<string, any> | undefined, any, (import('@tiptap/core').NodeType<any, any, any, any> | import('@tiptap/core').TextType<import('@tiptap/core').MarkType<any, any>>)[]>[]> | undefined;

package/dist/types/rich-text/__demo__/conversion-fixtures.d.ts

@@ -1,5 +1,5 @@
-import { KnowledgeSceneV1 } from '../public/types';
-import { LegacyKnowledgeItem, LegacyReferenceResolver } from '../legacy-converter';
+import { KnowledgeSceneV1 } from '../../index.ts';
+import { LegacyKnowledgeItem, LegacyReferenceResolver } from '../legacy-converter/index.ts';
 export interface ConversionFixture {
     id: string;
     label: string;

package/dist/types/rich-text/__demo__/reasoning-template-examples.d.ts

@@ -0,0 +1,11 @@
+import { JSONContent } from '@tiptap/core';
+export interface ReasoningTemplateExample {
+    id: string;
+    label: string;
+    name: string;
+    question: string;
+    content: string;
+}
+/** Bundled examples used when the host does not supply reasoning templates. */
+export declare const reasoningTemplateExamples: ReasoningTemplateExample[];
+export declare function reasoningTemplateDocument(example: ReasoningTemplateExample): JSONContent;

package/dist/types/rich-text/config/descriptor.d.ts

@@ -1,9 +1,11 @@
+import { FkpIconName } from '@freecallai/icons';
 import { CapabilityId, CapabilitySlot, KnowledgeType, RichTextHostPorts } from '../public/types';
 export declare const optionSourcePort: {
     readonly agents: "searchAgents";
     readonly variables: "listVariables";
     readonly flatTags: "listCapabilityOptions";
     readonly capabilities: "listCapabilityOptions";
+    readonly reasoningTemplates: "listCapabilityOptions";
 };
 export declare const hostActions: {
     readonly agentOpenConfig: {
@@ -24,7 +26,8 @@ export declare const hostActions: {
     };
     readonly reasoningTemplateLoad: {
         readonly id: "reasoningTemplate.load";
-        readonly requiredPorts: readonly ["getReasoningTemplate"];
+        readonly requiredPorts: readonly [];
+        readonly optionalPorts: readonly ["getReasoningTemplate", "listCapabilityOptions"];
     };
 };
 export interface CapabilityDescriptor {
@@ -33,13 +36,32 @@ export interface CapabilityDescriptor {
     dataVersion: number;
     implementation: 'plugin' | 'host';
     label: string;
+    /** Optional full name used when a type change removes this capability. */
+    removalLabel?: string;
     slot: CapabilitySlot;
     order: number;
     types: readonly KnowledgeType[];
-    icon: string;
+    icon: FkpIconName;
+    /** Trusted, local presentation metadata; never supplied by remote rules. */
+    menu?: {
+        title: string;
+        searchLabel: string;
+        classes: readonly string[];
+        width?: number;
+        helpClass: string;
+        guidance?: readonly string[];
+        guidanceClass?: string;
+        headingClass?: string;
+        badge?: {
+            text: string;
+            className: string;
+            dotClass: string;
+        };
+    };
     actions?: readonly {
         id: string;
         requiredPorts: readonly (keyof RichTextHostPorts)[];
+        optionalPorts?: readonly (keyof RichTextHostPorts)[];
     }[];
     /** Read-only view data dependencies; they do not execute editor operations. */
     readPorts?: readonly (keyof RichTextHostPorts)[];
@@ -54,5 +76,6 @@ export interface CapabilityDescriptor {
     uiPorts?: readonly (keyof RichTextHostPorts)[];
     questionTag?: {
         kind: 'todo' | 'default';
+        protocolLabel: string;
     };
 }

package/dist/types/rich-text/config/resolve.d.ts

@@ -4,6 +4,8 @@ import { SelectionOptions } from './selection-options';
 import { EditorDiagnostic, FkpRichTextProps, KnowledgeType } from '../public/types';
 export interface ResolvedCapability extends CapabilityDescriptor {
     canInsert: boolean;
+    /** Programmatic insertion supplies its own option or asset; menu/upload ports are not needed. */
+    canInsertProvided: boolean;
     visible: boolean;
     options?: MediaOptions | SelectionOptions;
 }

package/dist/types/rich-text/index.d.ts

@@ -1,6 +1,8 @@
 export { default } from './FkpRichText.vue';
 export { default as FkpRichText } from './FkpRichText.vue';
-export type { FkpRichTextProps, FkpRichTextHandle, KnowledgeSceneV1, KnowledgeConditionV1, MigrationIssueV1, LoadedConditionV1, LegacyReadonlyConditionV1, ConditionLoadV1, SaveConditionInputV1, SavedConditionV1, KnowledgePersistenceAdapterV1, KnowledgeType, CapabilityId, CapabilitySlot, CapabilityRuleV1, SceneConfigInputV1, RichTextHostPorts, PortRequestContext, PortResult, PortErrorCode, Page, CapabilityOption, ToolFormField, ToolFormDefinition, VariableOption, AgentSummary, AgentPrompt, MediaAsset, SceneConfigLayersV1, HostPolicySnapshotV1, EditorDiagnostic, ChangeMeta, } from './public/types';
+export { default as FkpKnowledgeTypePicker } from './ui/FkpKnowledgeTypePicker.vue';
+export type { FkpKnowledgeTypePickerProps } from './ui/knowledge-type-picker-types';
+export type { FkpRichTextProps, FkpRichTextHandle, RichTextInsertInput, RichTextInsertOption, RichTextInsertResult, KnowledgeSceneV1, KnowledgeConditionV1, MigrationIssueV1, LoadedConditionV1, LegacyReadonlyConditionV1, ConditionLoadV1, SaveConditionInputV1, SavedConditionV1, KnowledgePersistenceAdapterV1, KnowledgeType, AddKnowledgeSceneRequest, CapabilityId, CapabilitySlot, CapabilityRuleV1, SceneConfigInputV1, RichTextHostPorts, PortRequestContext, PortResult, PortErrorCode, Page, CapabilityOption, ToolFormField, ToolFormDefinition, VariableOption, AgentSummary, AgentPrompt, AgentPromptPreviewPart, MediaAsset, SceneConfigLayersV1, HostPolicySnapshotV1, EditorDiagnostic, ChangeMeta, } from './public/types';
 export { emptyScene, emptyDoc } from './public/types';
 export { resolveSceneConfig } from './config/resolve';
 export { validateKnowledgeScenes } from './model/validate';

package/dist/types/rich-text/legacy-converter/agent-prompt-preview.d.ts

@@ -0,0 +1,2 @@
+import { AgentPromptPreviewPart } from '../public/types';
+export declare function agentPromptPreview(html: string | null | undefined, plain: string | null | undefined): AgentPromptPreviewPart[];

package/dist/types/rich-text/legacy-converter/business-attribute.d.ts

@@ -0,0 +1,12 @@
+/** csr-webui's bizAttributeCatalog response; IDs, keys and names are stable protocol data. */
+export interface LegacyBusinessAttribute {
+    id: string | number;
+    key: string;
+    name: string;
+}
+/** Reject ambiguous or unrepresentable host catalog entries before converting data. */
+export declare function isLegacyBusinessAttributeCatalog(value: unknown): value is readonly LegacyBusinessAttribute[];
+export declare const LEGACY_BUSINESS_ATTRIBUTES: readonly LegacyBusinessAttribute[];
+export declare function legacyBusinessAttributeByName(name: string, attributes?: readonly LegacyBusinessAttribute[]): LegacyBusinessAttribute | undefined;
+export declare function legacyBusinessAttributeByKey(key: string, attributes?: readonly LegacyBusinessAttribute[]): LegacyBusinessAttribute | undefined;
+export declare function legacyBusinessAttributeToken(name: string): string;

package/dist/types/rich-text/legacy-converter/index.d.ts

@@ -1,4 +1,8 @@
 import { KnowledgeSceneV1 } from '../public/types';
+import { LegacyBusinessAttribute } from './business-attribute';
+export { LEGACY_BUSINESS_ATTRIBUTES, isLegacyBusinessAttributeCatalog, } from './business-attribute';
+export type { LegacyBusinessAttribute } from './business-attribute';
+export { agentPromptPreview } from './agent-prompt-preview';
 /** The old knowledge item. Unrelated backend fields are copied through on export. */
 export interface LegacyKnowledgeItem {
     web_content?: string;
@@ -20,10 +24,14 @@ export interface LegacyReferenceResolver {
     } | null;
 }
 export interface LegacyImportOptions {
+    /** Complete authoritative host catalog; omitted preserves the six legacy entries. */
+    businessAttributes?: readonly LegacyBusinessAttribute[];
     /** The parent condition owns the question when it is absent from web_content. */
     questionText?: string;
 }
 export interface LegacyExportOptions {
+    /** Use the same host catalog used to insert/import attribute references. */
+    businessAttributes?: readonly LegacyBusinessAttribute[];
     /** Real updateCondition content items normally store the question outside web_content. */
     questionStorage?: 'external' | 'inline';
 }

package/dist/types/rich-text/legacy-converter/tool-contract.d.ts

@@ -0,0 +1 @@
+export { parseLegacyToolText, formatLegacyToolText, parseEncodedOrderRemark, } from '../plugins/tool/protocol';

package/dist/types/rich-text/model/guard.d.ts

@@ -1,7 +1,8 @@
 import { JSONContent } from '@tiptap/core';
 import { KnowledgeSceneV1 } from '../public/types';
 export declare const isKnownNodeType: (type: string) => boolean;
-export declare function findUnsupportedContent(doc: JSONContent | null, rootPath?: string): string | null;
+/** Agent snapshots validate node structure without applying insert placement rules. */
+export declare function findUnsupportedContent(doc: JSONContent | null, rootPath?: string, allowStoredReplyTags?: boolean): string | null;
 /** The minimum shape required for the scene shell to render safely. */
 export declare function isRenderableSceneShell(value: unknown): value is KnowledgeSceneV1;
 export declare function findUnsupportedScene(value: unknown): string | null;

package/dist/types/rich-text/model/node-contract.d.ts

@@ -1,8 +1,6 @@
-/** Persisted node kinds. A new kind must be added here before it can enter a scene. */
-export declare const BUSINESS_TOKEN_KINDS: readonly ["todo", "ticket", "variable", "attribute", "tool", "separator"];
-export type BusinessTokenKind = (typeof BUSINESS_TOKEN_KINDS)[number];
-export declare const CHOICE_TOKEN_KINDS: readonly ["todo", "ticket", "attribute"];
-export type ChoiceTokenKind = (typeof CHOICE_TOKEN_KINDS)[number];
+import { BusinessTokenKind, ChoiceTokenKind } from '../plugins/token-catalog';
+export { BUSINESS_TOKEN_KINDS, CHOICE_TOKEN_KINDS, getBusinessTokenDefinition, } from '../plugins/token-catalog';
+export type { BusinessTokenKind, ChoiceTokenKind, } from '../plugins/token-catalog';
 export declare const MEDIA_KINDS: readonly ["image", "video"];
 export type MediaKind = (typeof MEDIA_KINDS)[number];
 export declare const isBusinessTokenKind: (value: unknown) => value is BusinessTokenKind;

package/dist/types/rich-text/model/node-identity.d.ts

@@ -1,6 +1,12 @@
 import { JSONContent } from '@tiptap/core';
+import { CapabilityId, CapabilitySlot } from '../public/types';
 export declare const isIdentifiedNodeType: (type: string) => boolean;
-export declare function ownerOfIdentifiedNode(type: string, attrs?: Record<string, unknown>): string | null;
+export declare function ownerOfIdentifiedNode(type: string, attrs?: Record<string, unknown>): CapabilityId | null;
+/** Structural legacy separators use the same placement policy as inline ones. */
+export declare function nodeCapability(node: JSONContent): {
+    id: CapabilityId;
+    slot: CapabilitySlot;
+} | null;
 export declare function hasNestedIdentifiedNode(node: JSONContent): boolean;
 export declare const trustedNodeIdsMeta = "fkpTrustedNodeIds";
 export declare function collectIdentifiedNodeIds(content: JSONContent | JSONContent[]): string[];

package/dist/types/rich-text/model/question-text.d.ts

@@ -1,10 +1,9 @@
-import { KnowledgeSceneV1 } from '../public/types';
-type SelectionCapability = 'todo' | 'tagged';
+import { CapabilityId, KnowledgeSceneV1 } from '../public/types';
 /** Historical/current brackets and line breaks are reserved intent delimiters. */
 export declare function hasQuestionDelimiter(text: string): boolean;
 /** Plan labels must remain one unambiguous model-protocol token. */
 export declare function hasPlanLabelDelimiter(label: string): boolean;
-export declare function selectedQuestionOption(scene: KnowledgeSceneV1, id: SelectionCapability): {
+export declare function selectedQuestionOption(scene: KnowledgeSceneV1, id: CapabilityId): {
     id: string;
     label: string;
 } | null;
@@ -12,4 +11,3 @@ export declare function selectedQuestionOption(scene: KnowledgeSceneV1, id: Sele
 export declare function serializeQuestionTagsForModel(scene: KnowledgeSceneV1): string;
 /** Produces the complete intent line when the host sends a prompt to the model. */
 export declare function serializeQuestionForModel(scene: KnowledgeSceneV1): string;
-export {};

package/dist/types/rich-text/plugins/attribute/token.d.ts

@@ -0,0 +1,9 @@
+export declare const attributeToken: {
+    allowInOriginalReply: false;
+    choice: true;
+    requiresInsertToken?: true;
+    allowsParams?: true;
+    present(attrs: import('../token-definition').TokenAttrs): import('../token-definition').TokenPresentation;
+    serialize(attrs: import('../token-definition').TokenAttrs): string;
+    validate?(attrs: import('../token-definition').TokenAttrs): string | null;
+};

package/dist/types/rich-text/plugins/operations.d.ts

@@ -77,10 +77,19 @@ export interface CapabilityModule {
     apiVersion: 1;
     dataVersion: number;
     actions: Readonly<Record<string, CapabilityAction>>;
+    /** Final synchronous check against the live scene after an async insert action. */
+    validateInsert?(input: PluginInput, scene: Readonly<KnowledgeSceneV1>): {
+        ok: true;
+    } | {
+        ok: false;
+        code: string;
+        message: string;
+    };
 }
 /** Shared behavior used by individual, identity-bound plugin modules. */
 export interface SharedCapabilityImplementation {
     execute(id: CapabilityId, input: PluginInput, scene: Readonly<KnowledgeSceneV1>): readonly PluginOperation[];
+    validateInsert?: CapabilityModule['validateInsert'];
 }
 export declare function bindCapability(id: CapabilityId, slot: CapabilitySlot, implementation: SharedCapabilityImplementation): CapabilityModule;
 export {};

package/dist/types/rich-text/plugins/reasoningTemplate/defaults.d.ts

@@ -0,0 +1,14 @@
+import { JSONContent } from '@tiptap/core';
+import { CapabilityOption, Page, PortResult } from '../../public/types';
+import { PluginActionContext } from '../operations';
+export declare function isDefaultTemplateCursor(cursor: string | undefined): boolean;
+export declare function defaultTemplateOptions(query: {
+    search?: string;
+    cursor?: string;
+    limit: number;
+}): PortResult<Page<CapabilityOption>>;
+/** Resolve references through declared host ports; never persist the demo's fake todo ID. */
+export declare function loadDefaultTemplate(id: string, context: PluginActionContext): Promise<PortResult<{
+    question: string;
+    doc: JSONContent;
+}> | null>;

package/dist/types/rich-text/plugins/reasoningTemplate/examples.d.ts

@@ -0,0 +1,9 @@
+export interface ReasoningTemplateExample {
+    id: string;
+    label: string;
+    name: string;
+    question: string;
+    content: string;
+}
+/** Bundled examples used when the host does not supply reasoning templates. */
+export declare const reasoningTemplateExamples: ReasoningTemplateExample[];

package/dist/types/rich-text/plugins/separator/token.d.ts

@@ -0,0 +1,2 @@
+import { BusinessTokenDefinition } from '../token-definition';
+export declare const separatorToken: BusinessTokenDefinition;

package/dist/types/rich-text/plugins/tableKnowledge/descriptor.d.ts

@@ -0,0 +1,2 @@
+import { CapabilityDescriptor } from '../../config/descriptor';
+export declare const tableKnowledgeDescriptors: readonly CapabilityDescriptor[];

package/dist/types/rich-text/plugins/tableKnowledge/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('../operations').CapabilityModule;
+export default _default;

package/dist/types/rich-text/plugins/tableKnowledge/token.d.ts

@@ -0,0 +1,9 @@
+export declare const tableKnowledgeToken: {
+    validate: (attrs: Readonly<Record<string, unknown>>) => "label" | null;
+    choice: true;
+    requiresInsertToken?: true;
+    allowsParams?: true;
+    allowInOriginalReply?: false;
+    present(attrs: import('../token-definition').TokenAttrs): import('../token-definition').TokenPresentation;
+    serialize(attrs: import('../token-definition').TokenAttrs): string;
+};

package/dist/types/rich-text/plugins/ticket/protocol.d.ts

@@ -0,0 +1,8 @@
+export declare function parseTicketText(text: string): {
+    key: string;
+    label: string;
+    params?: {
+        protocol: 'legacy';
+    };
+} | null;
+export declare function formatTicketText(key: string, label: string, params?: Record<string, unknown> | null): string;

package/dist/types/rich-text/plugins/ticket/token.d.ts

@@ -0,0 +1,9 @@
+export declare const ticketToken: {
+    allowsParams: true;
+    validate(attrs: Readonly<Record<string, unknown>>): "label" | "params" | "key" | null;
+    choice: true;
+    requiresInsertToken?: true;
+    allowInOriginalReply?: false;
+    present(attrs: import('../token-definition').TokenAttrs): import('../token-definition').TokenPresentation;
+    serialize(attrs: import('../token-definition').TokenAttrs): string;
+};

package/dist/types/rich-text/plugins/todo/token.d.ts

@@ -0,0 +1,3 @@
+export declare const todoToken: import('../token-definition').BusinessTokenDefinition & {
+    choice: true;
+};

package/dist/types/rich-text/plugins/token-catalog.d.ts

@@ -0,0 +1,46 @@
+import { BusinessTokenDefinition } from './token-definition';
+/** One registration per persisted inline kind; all behavior lives with its owner. */
+export declare const tokenCatalog: {
+    todo: BusinessTokenDefinition & {
+        choice: true;
+    };
+    ticket: {
+        allowsParams: true;
+        validate(attrs: Readonly<Record<string, unknown>>): "label" | "params" | "key" | null;
+        choice: true;
+        requiresInsertToken?: true;
+        allowInOriginalReply?: false;
+        present(attrs: import('./token-definition').TokenAttrs): import('./token-definition').TokenPresentation;
+        serialize(attrs: import('./token-definition').TokenAttrs): string;
+    };
+    tableKnowledge: {
+        validate: (attrs: Readonly<Record<string, unknown>>) => "label" | null;
+        choice: true;
+        requiresInsertToken?: true;
+        allowsParams?: true;
+        allowInOriginalReply?: false;
+        present(attrs: import('./token-definition').TokenAttrs): import('./token-definition').TokenPresentation;
+        serialize(attrs: import('./token-definition').TokenAttrs): string;
+    };
+    variable: BusinessTokenDefinition;
+    attribute: {
+        allowInOriginalReply: false;
+        choice: true;
+        requiresInsertToken?: true;
+        allowsParams?: true;
+        present(attrs: import('./token-definition').TokenAttrs): import('./token-definition').TokenPresentation;
+        serialize(attrs: import('./token-definition').TokenAttrs): string;
+        validate?(attrs: import('./token-definition').TokenAttrs): string | null;
+    };
+    tool: BusinessTokenDefinition;
+    separator: BusinessTokenDefinition;
+};
+export type BusinessTokenKind = keyof typeof tokenCatalog;
+export type ChoiceTokenKind = {
+    [K in BusinessTokenKind]: (typeof tokenCatalog)[K] extends {
+        choice: true;
+    } ? K : never;
+}[BusinessTokenKind];
+export declare function getBusinessTokenDefinition(kind: unknown): BusinessTokenDefinition | undefined;
+export declare const BUSINESS_TOKEN_KINDS: BusinessTokenKind[];
+export declare const CHOICE_TOKEN_KINDS: ChoiceTokenKind[];

package/dist/types/rich-text/plugins/token-definition.d.ts

@@ -0,0 +1,24 @@
+import { FkpIconName } from '@freecallai/icons';
+export type TokenAttrs = Readonly<Record<string, unknown>>;
+export interface TokenPresentation {
+    layout: 'choice' | 'inline' | 'tool' | 'toolNote';
+    icon: FkpIconName;
+    label: string;
+    ariaLabel: string;
+    className?: string;
+    summary?: string;
+}
+/** Pure metadata/codecs: importing these contracts never loads editor views. */
+export interface BusinessTokenDefinition {
+    choice?: true;
+    requiresInsertToken?: true;
+    allowsParams?: true;
+    allowInOriginalReply?: false;
+    present(attrs: TokenAttrs): TokenPresentation;
+    serialize(attrs: TokenAttrs): string;
+    /** Return the relative attribute field that cannot be represented safely. */
+    validate?(attrs: TokenAttrs): string | null;
+}
+export declare function choiceToken(label: string, icon: FkpIconName, serialize: BusinessTokenDefinition['serialize']): BusinessTokenDefinition & {
+    choice: true;
+};

package/dist/types/rich-text/plugins/tool/presentation.d.ts

@@ -1,6 +1,7 @@
+import { FkpIconName } from '@freecallai/icons';
 export interface ToolTokenPresentation {
     label: string;
-    iconGlyph: string;
+    icon: FkpIconName;
     summary: string;
 }
 /** Built-in tool display rules live with the tool plugin, not the editor schema. */

package/dist/types/rich-text/plugins/tool/protocol.d.ts

@@ -0,0 +1,5 @@
+import { JSONContent } from '@tiptap/core';
+export declare function parseLegacyToolText(text: string): JSONContent | null;
+export declare function formatLegacyToolText(node: JSONContent): string | null;
+/** Older csr-webui drafts stored encoded JSON before the explicit span protocol. */
+export declare function parseEncodedOrderRemark(value: string): JSONContent | null;