@wordbricks/persona 0.1.0

package/dist/index-swXvBCre.d.ts

@@ -0,0 +1,622 @@
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { PersonaEmbeddingTargetKind, PersonaProfile, PersonaAliasSurface, PersonaAlias, PersonaWorkspacePayload, PersonaMemoryState, PersonaBeliefType, PersonaPrivacyLevel, PersonaBeliefStance, NewPersonaEpisodeMemory, PersonaFactType, PersonaFactObjectType, PersonaToneVector, PersonaSourceDocument, PersonaEmotionAnnotation, PersonaSemanticBelief } from './schema/index.js';
+import { x as PersonaTurnPlan, p as PersonaMemoryType, u as PersonaQueryType, i as PersonaLogger, f as PersonaEmbedder, c as PersonaAffectVector, w as PersonaTurnAffectEstimate, t as PersonaMoodUpdateTrace, j as PersonaMemoryCandidate, e as PersonaContextGatewayOutput, q as PersonaMoodEmotionLabel, k as PersonaMemorySelectionResult, D as DisclosurePolicy, h as PersonaJsonLlm, v as PersonaRuntimeContext, l as PersonaMemoryTriageDecision } from './types-BHEW4MGH.js';
+
+type PersonaDatabase = PostgresJsDatabase<Record<string, unknown>>;
+
+type HindsightPersonaMemoryEnv = {
+    HINDSIGHT_ENABLED?: boolean | string;
+    HINDSIGHT_API_KEY?: string;
+    HINDSIGHT_BASE_URL?: string;
+    HINDSIGHT_TIMEOUT_MS?: number | string;
+    HINDSIGHT_RECALL_ENABLED?: boolean | string;
+    HINDSIGHT_RECALL_TOP_K?: number | string;
+    HINDSIGHT_RETAIN_ENABLED?: boolean | string;
+    HINDSIGHT_RETAIN_ASYNC_ENABLED?: boolean | string;
+    HINDSIGHT_REFLECT_ENABLED?: boolean | string;
+    HINDSIGHT_REFLECT_TIMEOUT_MS?: number | string;
+    HINDSIGHT_FAIL_OPEN?: boolean | string;
+};
+type HindsightPersonaMemoryConfig = {
+    apiKey: string | null;
+    baseUrl: string | null;
+    enabled: boolean;
+    failOpen: boolean;
+    recallEnabled: boolean;
+    recallTopK: number;
+    reflectEnabled: boolean;
+    reflectTimeoutMs: number;
+    retainAsyncEnabled: boolean;
+    retainEnabled: boolean;
+    timeoutMs: number;
+};
+type HindsightRecallInput = {
+    contextKeys: PersonaTurnPlan["context"]["contextKeys"];
+    desiredMemoryTypes: PersonaMemoryType[];
+    maxResults: number;
+    message: string;
+    organizationId: string;
+    personaId: string;
+    personaKey: string;
+    retrievalQueries: PersonaTurnPlan["context"]["retrievalQueries"];
+    turnQueryType: PersonaQueryType;
+    userId: string;
+};
+type HindsightRawRecallMemory = {
+    bankId: string;
+    chunkId: string | null;
+    context: string | null;
+    documentId: string | null;
+    entities: string[];
+    id: string;
+    mentionedAt: string | null;
+    metadata: Record<string, string>;
+    occurredEnd: string | null;
+    occurredStart: string | null;
+    sourceFactIds: string[];
+    tags: string[];
+    text: string;
+    type: string | null;
+};
+type HindsightRecallResult = {
+    attempted: boolean;
+    enabled: boolean;
+    latencyMs?: number;
+    memories: HindsightRawRecallMemory[];
+    provider: "hindsight";
+    skippedReason?: string;
+};
+type HindsightRetainInput = {
+    chatMessageId?: string | null;
+    chatSessionId?: string | null;
+    content: string;
+    context?: string | null;
+    documentId?: string | null;
+    organizationId: string;
+    personaId: string;
+    personaKey: string;
+    privacyLevel: "public" | "internal" | "private" | "sensitive";
+    scope: "persona_global" | "persona_user";
+    tags?: string[];
+    themes?: string[];
+    timestamp?: Date | string | null;
+    userId?: string | null;
+};
+type HindsightRetainResult = {
+    attempted: boolean;
+    bankId?: string;
+    enabled: boolean;
+    error?: string;
+    latencyMs?: number;
+    operationId?: string | null;
+    provider: "hindsight";
+    skippedReason?: string;
+    succeeded: boolean;
+};
+type HindsightReflectInput = {
+    context?: string | null;
+    maxTokens?: number;
+    organizationId: string;
+    personaId: string;
+    personaKey: string;
+    query: string;
+    scope: "persona_global" | "persona_user";
+    tags?: string[];
+    userId?: string | null;
+};
+type HindsightReflectResult = {
+    attempted: boolean;
+    enabled: boolean;
+    error?: string;
+    latencyMs?: number;
+    provider: "hindsight";
+    skippedReason?: string;
+    text: string | null;
+};
+type HindsightPersonaMemoryClient = {
+    recall(input: HindsightRecallInput): Promise<HindsightRecallResult>;
+    reflect(input: HindsightReflectInput): Promise<HindsightReflectResult>;
+    retain(input: HindsightRetainInput): Promise<HindsightRetainResult>;
+};
+type FetchLike = typeof fetch;
+declare function createHindsightPersonaMemoryConfig(env?: HindsightPersonaMemoryEnv | null): HindsightPersonaMemoryConfig;
+declare function createNoopHindsightPersonaMemoryClient(reason?: string): HindsightPersonaMemoryClient;
+declare function hindsightPersonaBankId(input: {
+    organizationId: string;
+    personaId: string;
+    scope: "persona_global" | "persona_user";
+    userId?: string | null;
+}): string;
+declare function hindsightPersonaTags(input: {
+    organizationId: string;
+    personaId: string;
+    themes?: string[];
+    userId?: string | null;
+}): string[];
+declare function createHindsightPersonaMemoryClient(config: HindsightPersonaMemoryConfig, fetchImpl?: FetchLike, logger?: PersonaLogger): HindsightPersonaMemoryClient;
+
+declare function createOpenAiPersonaEmbedder(openaiApiKey?: string | null): PersonaEmbedder | undefined;
+declare function hashPersonaMemoryText(text: string): string;
+type PersonaMemoryEmbeddingEntry = {
+    organizationId: string;
+    personaId: string;
+    targetId: string;
+    targetKind: PersonaEmbeddingTargetKind;
+    text: string;
+};
+declare function normalizePersonaEmbeddingText(text: string): string;
+declare function upsertPersonaMemoryEmbeddings(db: PersonaDatabase, input: {
+    embed: PersonaEmbedder;
+    entries: PersonaMemoryEmbeddingEntry[];
+    logger?: PersonaLogger;
+}): Promise<number>;
+declare function backfillPersonaMemoryEmbeddings(db: PersonaDatabase, input: {
+    embed?: PersonaEmbedder;
+    limit?: number;
+    logger?: PersonaLogger;
+}): Promise<{
+    embedded: number;
+}>;
+
+type PersonaProfileDeleteCounts = {
+    aliases: number;
+    beliefs: number;
+    embeddings: number;
+    emotionalSalience: number;
+    episodes: number;
+    externalMemoryRefs: number;
+    facts: number;
+    habits: number;
+    interactionMemories: number;
+    moodStates: number;
+    sourceChunks: number;
+    sourceDocuments: number;
+    styleProfiles: number;
+    workspaceStates: number;
+};
+declare function deletePersonaProfile(db: PersonaDatabase, input: {
+    organizationId: string;
+    personaKey: string;
+    updatedByUserId?: string | null;
+}): Promise<{
+    deletedCounts: PersonaProfileDeleteCounts;
+    profile: PersonaProfile;
+}>;
+
+declare const PERSONA_MOOD_BASELINE: PersonaAffectVector;
+declare function estimateTurnAffect(input: {
+    selected: PersonaMemoryCandidate[];
+    turnPlan: PersonaTurnPlan;
+}): PersonaAffectVector | null;
+declare function explainTurnAffect(input: {
+    selected: PersonaMemoryCandidate[];
+    turnPlan: PersonaTurnPlan;
+}): PersonaTurnAffectEstimate;
+declare function updatePersonaMood(input: {
+    current: PersonaAffectVector | null;
+    elapsedMs: number;
+    impulse: PersonaAffectVector | null;
+}): PersonaAffectVector;
+declare function calculatePersonaMoodUpdate(input: {
+    current: PersonaAffectVector | null;
+    elapsedMs: number;
+    impulse: PersonaAffectVector | null;
+    turnAffect?: PersonaTurnAffectEstimate | null;
+}): {
+    mood: PersonaAffectVector;
+    trace: PersonaMoodUpdateTrace;
+};
+
+declare function loadPersonaProfile(db: PersonaDatabase, input: {
+    organizationId: string;
+    personaKey: string;
+}): Promise<PersonaProfile>;
+declare function upsertPersonaProfile(db: PersonaDatabase, input: {
+    consentStatus?: PersonaProfile["consentStatus"];
+    displayName?: string | null;
+    organizationId: string;
+    personaKey: string;
+    personaType?: PersonaProfile["personaType"];
+    personaVersion?: string | null;
+    policy?: Partial<PersonaProfile["policy"]>;
+    profile?: Record<string, unknown>;
+    sourceRef?: string | null;
+    updatedByUserId?: string | null;
+}): Promise<PersonaProfile>;
+declare function upsertPersonaAlias(db: PersonaDatabase, input: {
+    aliasKey: string;
+    organizationId: string;
+    personaKey: string;
+    state?: PersonaAlias["state"];
+    surface?: PersonaAliasSurface;
+    updatedByUserId?: string | null;
+}): Promise<PersonaAlias>;
+declare function listPersonaAliases(db: PersonaDatabase, input: {
+    organizationId: string;
+    personaKey?: string | null;
+    surface?: PersonaAliasSurface;
+}): Promise<Array<PersonaAlias & {
+    personaKey: string;
+}>>;
+declare function forgetPersonaLayerMemory(db: PersonaDatabase, input: {
+    memoryId: string;
+    organizationId: string;
+    personaKey: string;
+    sourceTitle?: string | null;
+}): Promise<{
+    forgottenEmbeddings: number;
+    forgottenMemory: {
+        id: string;
+        memoryKind: "episode" | "fact" | "belief" | "habit" | "style";
+        title: string;
+    };
+    forgottenSourceChunks: number;
+    forgottenSourceDocuments: number;
+}>;
+declare function copyPersonaProfile(db: PersonaDatabase, input: {
+    sourcePersonaKey: string;
+    targetOrganizationId: string;
+    targetPersonaKey?: string | null;
+    updatedByUserId?: string | null;
+}): Promise<{
+    copiedCounts: {
+        beliefs: number;
+        episodes: number;
+        habits: number;
+        sourceChunks: number;
+        sourceDocuments: number;
+        styleProfiles: number;
+    };
+    persona: PersonaProfile;
+    sourcePersona: PersonaProfile;
+}>;
+declare function publishPersonaProfile(db: PersonaDatabase, input: {
+    organizationId: string;
+    personaKey: string;
+    publicPersonaKey?: string | null;
+    updatedByUserId?: string | null;
+}): Promise<{
+    persona: PersonaProfile;
+    publishedCounts: {
+        beliefs: number;
+        episodes: number;
+        habits: number;
+        sourceChunks: number;
+        sourceDocuments: number;
+        styleProfiles: number;
+    };
+    sourcePersona: PersonaProfile;
+}>;
+declare function listPublicPersonaProfiles(db: PersonaDatabase): Promise<PersonaProfile[]>;
+
+declare const PERSONA_TURN_PLANNER_SYSTEM_PROMPT: string;
+declare const PERSONA_CONSOLIDATION_SYSTEM_PROMPT: string;
+declare const PERSONA_SOURCE_DRAFTING_SYSTEM_PROMPT: string;
+declare const PERSONA_MEMORY_TRIAGE_SYSTEM_PROMPT: string;
+
+declare function normalizeCosineSimilarity(value: number | null): number;
+declare function calculateMemoryAvailability(input: {
+    candidate: Pick<PersonaMemoryCandidate, "activationCount" | "createdAt" | "kind" | "lastActivatedAt" | "sourceConfidence">;
+    now: Date;
+}): number;
+declare function selectPersonaMemories(input: {
+    candidates: PersonaMemoryCandidate[];
+    context: PersonaContextGatewayOutput;
+    mood?: PersonaAffectVector | null;
+    moodEmotionLabels?: PersonaMoodEmotionLabel[] | null;
+    now?: Date;
+}): PersonaMemoryCandidate[];
+declare function selectPersonaMemoriesWithScores(input: {
+    candidates: PersonaMemoryCandidate[];
+    context: PersonaContextGatewayOutput;
+    mood?: PersonaAffectVector | null;
+    moodEmotionLabels?: PersonaMoodEmotionLabel[] | null;
+    now?: Date;
+}): PersonaMemorySelectionResult;
+
+declare function formatWorkspacePrompt(input: {
+    disclosurePolicy?: DisclosurePolicy;
+    mood?: PersonaAffectVector | null;
+    moodUpdate?: PersonaMoodUpdateTrace | null;
+    profile: PersonaProfile;
+    turnPlan: PersonaTurnPlan;
+    selected: PersonaMemoryCandidate[];
+    workspacePayload: PersonaWorkspacePayload;
+}): string;
+declare function recallPersonaMemoriesForCue(db: PersonaDatabase, input: {
+    cue: string;
+    embed?: PersonaEmbedder;
+    logger?: PersonaLogger;
+    organizationId: string;
+    personaKey: string;
+}): Promise<string>;
+declare function planPersonaTurnWithLlm(input: {
+    llm: PersonaJsonLlm;
+    message: string;
+    persona: PersonaProfile;
+}): Promise<PersonaTurnPlan>;
+type PostResponseMemoryReview = NonNullable<PersonaWorkspacePayload["memoryReview"]>;
+declare function evaluatePostResponseInteractionMemory(input: {
+    assistantMessage: string;
+    turnPlan: PersonaTurnPlan;
+    userMessage: string;
+}): {
+    memoryIntent: "self_correction_feedback" | "durable_product_lesson" | null;
+    reason: string;
+    shouldRemember: boolean;
+    summary: string | null;
+    themes: string[];
+};
+declare function recordPostResponsePersonaMemoryReview(db: PersonaDatabase, input: {
+    assistantMessage: string;
+    assistantMessageId?: string | null;
+    chatSessionId?: string | null;
+    defer?: (promise: Promise<unknown>) => void;
+    hindsight?: HindsightPersonaMemoryClient | null;
+    logger?: PersonaLogger;
+    llm?: PersonaJsonLlm;
+    organizationId: string;
+    persona: PersonaProfile;
+    turnPlan: PersonaTurnPlan;
+    userId: string;
+    userMessage: string;
+    workspaceId: string;
+}): Promise<PostResponseMemoryReview>;
+declare function triageInteractionMemoryWithLlm(input: {
+    logger?: PersonaLogger;
+    llm?: PersonaJsonLlm;
+    message: string;
+    persona: PersonaProfile;
+    selected?: PersonaMemoryCandidate[];
+    turnPlan: PersonaTurnPlan;
+}): Promise<PersonaMemoryTriageDecision>;
+declare function triagePostResponseInteractionMemoryWithLlm(input: {
+    assistantMessage: string;
+    logger?: PersonaLogger;
+    llm?: PersonaJsonLlm;
+    persona: PersonaProfile;
+    turnPlan: PersonaTurnPlan;
+    userMessage: string;
+}): Promise<PersonaMemoryTriageDecision>;
+declare function shouldRecordInteractionMemory(input: {
+    message: string;
+    selected?: PersonaMemoryCandidate[];
+    turnPlan: PersonaTurnPlan;
+}): boolean;
+declare function preparePersonaRuntimeContext(db: PersonaDatabase, input: {
+    chatMessageId?: string | null;
+    chatSessionId?: string | null;
+    defer?: (promise: Promise<unknown>) => void;
+    disclosurePolicy?: DisclosurePolicy;
+    embed?: PersonaEmbedder;
+    hindsight?: HindsightPersonaMemoryClient | null;
+    logger?: PersonaLogger;
+    llm: PersonaJsonLlm;
+    message: string;
+    organizationId: string;
+    personaKey: string;
+    userId: string;
+}): Promise<PersonaRuntimeContext>;
+
+declare function hashPersonaSourceContent(text: string): Promise<string>;
+type PersonaSourceTextChunk = {
+    endChar: number;
+    startChar: number;
+    text: string;
+};
+declare function chunkPersonaSourceText(rawText: string, input?: {
+    maxChars?: number;
+    overlapChars?: number;
+}): PersonaSourceTextChunk[];
+declare function formatPersonaSourceExcerptForQuery(input: {
+    maxChars?: number;
+    query: string;
+    text: string;
+}): string;
+type PersonaSourceIngestionResult = {
+    chunkCount: number;
+    sourceDocument: PersonaSourceDocument;
+};
+declare function ingestPersonaSourceDocument(db: PersonaDatabase, input: {
+    author?: string | null;
+    consentStatus?: PersonaSourceDocument["consentStatus"] | null;
+    defer?: (promise: Promise<unknown>) => void;
+    embed?: PersonaEmbedder;
+    hindsight?: HindsightPersonaMemoryClient | null;
+    logger?: PersonaLogger;
+    metadata?: Record<string, unknown>;
+    organizationId: string;
+    personaKey: string;
+    privacyLevel?: PersonaPrivacyLevel | null;
+    publicationDate?: string | null;
+    rawText: string;
+    reliability?: number | null;
+    rightsStatus?: PersonaSourceDocument["rightsStatus"] | null;
+    sourcePriority?: PersonaSourceDocument["sourcePriority"] | null;
+    sourceType?: PersonaSourceDocument["sourceType"] | null;
+    sourceUri?: string | null;
+    title: string;
+}): Promise<PersonaSourceIngestionResult>;
+type PersonaSourceDraftEpisode = {
+    confidence: number;
+    eventSummary: string;
+    firstPersonRecollection?: string | null;
+    privacyLevel?: PersonaPrivacyLevel | null;
+    quoteSpan?: string | null;
+    sourceChunkIds?: string[];
+    themes?: string[];
+    thoughtAnnotations?: string[];
+    time?: NewPersonaEpisodeMemory["time"];
+    title: string;
+};
+type PersonaSourceDraftBelief = {
+    beliefType: PersonaBeliefType;
+    confidence: number;
+    domain: string;
+    exceptions?: string[];
+    firstPersonForm?: string | null;
+    privacyLevel?: PersonaPrivacyLevel | null;
+    proposition: string;
+    sourceChunkIds?: string[];
+    stance?: PersonaBeliefStance;
+    strength?: number | null;
+};
+type PersonaSourceDraftFact = {
+    beliefType?: PersonaBeliefType;
+    claimText?: string;
+    confidence: number;
+    domain?: string;
+    evidenceSpan?: string | null;
+    fact?: string;
+    factType?: PersonaFactType | null;
+    firstPersonForm?: string | null;
+    objectKey?: string | null;
+    objectName?: string | null;
+    objectType?: PersonaFactObjectType | null;
+    privacyLevel?: PersonaPrivacyLevel | null;
+    sourceChunkIds?: string[];
+    strength?: number | null;
+};
+type PersonaSourceDraftHabit = {
+    avoidPatterns?: string[];
+    confidence: number;
+    defaultResponsePattern: string[];
+    rhetoricalMoves?: string[];
+    sourceChunkIds?: string[];
+    strength?: number | null;
+    tone?: PersonaToneVector;
+    trigger: {
+        description: string;
+        type: string;
+    };
+};
+type PersonaSourceDraftStyleProfile = {
+    avoidPhrases?: string[];
+    commonPhrases?: string[];
+    lexicalPreferences?: {
+        avoids?: string[];
+        uses?: string[];
+    };
+    preferredRhetoricalMoves?: string[];
+    register: string;
+    sentenceLength: string;
+    sourceChunkIds?: string[];
+    toneVector?: PersonaToneVector;
+};
+type PersonaSourceDraftMemoryInput = {
+    beliefs?: PersonaSourceDraftBelief[];
+    episodes?: PersonaSourceDraftEpisode[];
+    habits?: PersonaSourceDraftHabit[];
+    sourceFacts?: PersonaSourceDraftFact[];
+    styleProfiles?: PersonaSourceDraftStyleProfile[];
+};
+type PersonaDraftMemorySummary = {
+    id: string;
+    memoryKind: "episode" | "fact" | "belief" | "habit" | "style";
+    state: PersonaMemoryState;
+    title: string;
+};
+type PersonaSourceDraftMemoryResult = {
+    drafts: PersonaDraftMemorySummary[];
+    sourceDocumentId: string;
+};
+declare function draftPersonaMemoriesFromSourceDocument(db: PersonaDatabase, input: {
+    draft: PersonaSourceDraftMemoryInput;
+    embed?: PersonaEmbedder;
+    logger?: PersonaLogger;
+    organizationId: string;
+    personaKey: string;
+    sourceDocumentId: string;
+}): Promise<PersonaSourceDraftMemoryResult>;
+declare function activatePersonaDraftMemory(db: PersonaDatabase, input: {
+    memoryId: string;
+    memoryKind: "episode" | "fact" | "belief" | "habit" | "style";
+    organizationId: string;
+    personaKey: string;
+}): Promise<PersonaDraftMemorySummary | null>;
+
+declare function applyBeliefReinforcement(belief: Pick<PersonaSemanticBelief, "confidence" | "strength">, input: {
+    evidenceConfidence: number;
+}): {
+    confidence: number;
+    strength: number;
+};
+declare function applyBeliefContradiction(belief: Pick<PersonaSemanticBelief, "confidence" | "strength">, input: {
+    evidenceConfidence: number;
+}): {
+    confidence: number;
+    state: PersonaMemoryState;
+    strength: number;
+};
+declare function parsePersonaToneVector(value: unknown): PersonaToneVector;
+declare function parsePersonaBeliefStance(value: unknown): PersonaBeliefStance;
+declare function parsePersonaLexicalPreferences(value: unknown): {
+    uses?: string[];
+    avoids?: string[];
+};
+type PersonaEpisodeAffectInput = {
+    arousal: number;
+    dominance: number;
+    emotions: PersonaEmotionAnnotation[];
+    retrievalBoost: number;
+    salienceScore: number;
+    selfRelevance: number;
+    valence: number;
+};
+declare function parsePersonaEpisodeAffect(value: unknown): PersonaEpisodeAffectInput | null;
+declare function rememberPersonaLayerMemory(db: PersonaDatabase, input: {
+    confidence?: number | null;
+    content?: Record<string, unknown> | null;
+    defer?: (promise: Promise<unknown>) => void;
+    embed?: PersonaEmbedder;
+    hindsight?: HindsightPersonaMemoryClient | null;
+    logger?: PersonaLogger;
+    memoryKind: "episode" | "fact" | "belief" | "habit" | "style" | "interaction";
+    organizationId: string;
+    personaKey: string;
+    privacyLevel?: PersonaPrivacyLevel | null;
+    summary: string;
+    title: string;
+    updatedByUserId?: string | null;
+    userId?: string | null;
+}): Promise<{
+    id: string;
+    memoryKind: "episode" | "fact" | "belief" | "habit" | "style" | "interaction";
+}>;
+declare function consolidatePersonaMemoryScope(input: {
+    consolidate: PersonaJsonLlm;
+    db: PersonaDatabase;
+    defer?: (promise: Promise<unknown>) => void;
+    embed?: PersonaEmbedder;
+    hindsight?: HindsightPersonaMemoryClient | null;
+    logger?: PersonaLogger;
+    organizationId: string;
+    personaKey: string;
+    userId?: string | null;
+}): Promise<{
+    contradictedBeliefs: number;
+    createdBeliefs: number;
+    createdEpisodes: number;
+    createdHabits: number;
+    createdStyleProfiles: number;
+    personaKey: string;
+    reinforcedBeliefs: number;
+}>;
+declare function processPersonaMemoryConsolidationTick(input: {
+    consolidate: PersonaJsonLlm;
+    db: PersonaDatabase;
+    embed?: PersonaEmbedder;
+    logger?: PersonaLogger;
+    now?: Date;
+}): Promise<{
+    processedScopes: number;
+    contradictedBeliefs: number;
+    createdBeliefs: number;
+    createdEpisodes: number;
+    createdHabits: number;
+    createdStyleProfiles: number;
+    embeddedMemories: number;
+    reinforcedBeliefs: number;
+}>;
+
+export { ingestPersonaSourceDocument as $, activatePersonaDraftMemory as A, applyBeliefContradiction as B, applyBeliefReinforcement as C, backfillPersonaMemoryEmbeddings as D, calculateMemoryAvailability as E, calculatePersonaMoodUpdate as F, chunkPersonaSourceText as G, type HindsightPersonaMemoryClient as H, consolidatePersonaMemoryScope as I, copyPersonaProfile as J, createHindsightPersonaMemoryClient as K, createHindsightPersonaMemoryConfig as L, createNoopHindsightPersonaMemoryClient as M, createOpenAiPersonaEmbedder as N, deletePersonaProfile as O, PERSONA_CONSOLIDATION_SYSTEM_PROMPT as P, draftPersonaMemoriesFromSourceDocument as Q, estimateTurnAffect as R, evaluatePostResponseInteractionMemory as S, explainTurnAffect as T, forgetPersonaLayerMemory as U, formatPersonaSourceExcerptForQuery as V, formatWorkspacePrompt as W, hashPersonaMemoryText as X, hashPersonaSourceContent as Y, hindsightPersonaBankId as Z, hindsightPersonaTags as _, type HindsightPersonaMemoryConfig as a, listPersonaAliases as a0, listPublicPersonaProfiles as a1, loadPersonaProfile as a2, normalizeCosineSimilarity as a3, normalizePersonaEmbeddingText as a4, parsePersonaBeliefStance as a5, parsePersonaEpisodeAffect as a6, parsePersonaLexicalPreferences as a7, parsePersonaToneVector as a8, planPersonaTurnWithLlm as a9, preparePersonaRuntimeContext as aa, processPersonaMemoryConsolidationTick as ab, publishPersonaProfile as ac, recallPersonaMemoriesForCue as ad, recordPostResponsePersonaMemoryReview as ae, rememberPersonaLayerMemory as af, selectPersonaMemories as ag, selectPersonaMemoriesWithScores as ah, shouldRecordInteractionMemory as ai, triageInteractionMemoryWithLlm as aj, triagePostResponseInteractionMemoryWithLlm as ak, updatePersonaMood as al, upsertPersonaAlias as am, upsertPersonaMemoryEmbeddings as an, upsertPersonaProfile as ao, type HindsightPersonaMemoryEnv as b, type HindsightRecallInput as c, type HindsightRecallResult as d, type HindsightReflectInput as e, type HindsightReflectResult as f, type HindsightRetainInput as g, type HindsightRetainResult as h, PERSONA_MEMORY_TRIAGE_SYSTEM_PROMPT as i, PERSONA_MOOD_BASELINE as j, PERSONA_SOURCE_DRAFTING_SYSTEM_PROMPT as k, PERSONA_TURN_PLANNER_SYSTEM_PROMPT as l, type PersonaDatabase as m, type PersonaDraftMemorySummary as n, type PersonaEpisodeAffectInput as o, type PersonaMemoryEmbeddingEntry as p, type PersonaProfileDeleteCounts as q, type PersonaSourceDraftBelief as r, type PersonaSourceDraftEpisode as s, type PersonaSourceDraftFact as t, type PersonaSourceDraftHabit as u, type PersonaSourceDraftMemoryInput as v, type PersonaSourceDraftMemoryResult as w, type PersonaSourceDraftStyleProfile as x, type PersonaSourceIngestionResult as y, type PersonaSourceTextChunk as z };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { PersonaLanguage, buildPersonaInstructions } from './agent/index.js';
+export { H as HindsightPersonaMemoryClient, a as HindsightPersonaMemoryConfig, b as HindsightPersonaMemoryEnv, c as HindsightRecallInput, d as HindsightRecallResult, e as HindsightReflectInput, f as HindsightReflectResult, g as HindsightRetainInput, h as HindsightRetainResult, P as PERSONA_CONSOLIDATION_SYSTEM_PROMPT, i as PERSONA_MEMORY_TRIAGE_SYSTEM_PROMPT, j as PERSONA_MOOD_BASELINE, k as PERSONA_SOURCE_DRAFTING_SYSTEM_PROMPT, l as PERSONA_TURN_PLANNER_SYSTEM_PROMPT, m as PersonaDatabase, n as PersonaDraftMemorySummary, o as PersonaEpisodeAffectInput, p as PersonaMemoryEmbeddingEntry, q as PersonaProfileDeleteCounts, r as PersonaSourceDraftBelief, s as PersonaSourceDraftEpisode, t as PersonaSourceDraftFact, u as PersonaSourceDraftHabit, v as PersonaSourceDraftMemoryInput, w as PersonaSourceDraftMemoryResult, x as PersonaSourceDraftStyleProfile, y as PersonaSourceIngestionResult, z as PersonaSourceTextChunk, A as activatePersonaDraftMemory, B as applyBeliefContradiction, C as applyBeliefReinforcement, D as backfillPersonaMemoryEmbeddings, E as calculateMemoryAvailability, F as calculatePersonaMoodUpdate, G as chunkPersonaSourceText, I as consolidatePersonaMemoryScope, J as copyPersonaProfile, K as createHindsightPersonaMemoryClient, L as createHindsightPersonaMemoryConfig, M as createNoopHindsightPersonaMemoryClient, N as createOpenAiPersonaEmbedder, O as deletePersonaProfile, Q as draftPersonaMemoriesFromSourceDocument, R as estimateTurnAffect, S as evaluatePostResponseInteractionMemory, T as explainTurnAffect, U as forgetPersonaLayerMemory, V as formatPersonaSourceExcerptForQuery, W as formatWorkspacePrompt, X as hashPersonaMemoryText, Y as hashPersonaSourceContent, Z as hindsightPersonaBankId, _ as hindsightPersonaTags, $ as ingestPersonaSourceDocument, a0 as listPersonaAliases, a1 as listPublicPersonaProfiles, a2 as loadPersonaProfile, a3 as normalizeCosineSimilarity, a4 as normalizePersonaEmbeddingText, a5 as parsePersonaBeliefStance, a6 as parsePersonaEpisodeAffect, a7 as parsePersonaLexicalPreferences, a8 as parsePersonaToneVector, a9 as planPersonaTurnWithLlm, aa as preparePersonaRuntimeContext, ab as processPersonaMemoryConsolidationTick, ac as publishPersonaProfile, ad as recallPersonaMemoriesForCue, ae as recordPostResponsePersonaMemoryReview, af as rememberPersonaLayerMemory, ag as selectPersonaMemories, ah as selectPersonaMemoriesWithScores, ai as shouldRecordInteractionMemory, aj as triageInteractionMemoryWithLlm, ak as triagePostResponseInteractionMemoryWithLlm, al as updatePersonaMood, am as upsertPersonaAlias, an as upsertPersonaMemoryEmbeddings, ao as upsertPersonaProfile } from './index-swXvBCre.js';
+export { NewPersonaAlias, NewPersonaAuditLog, NewPersonaEmotionalSalience, NewPersonaEpisodeMemory, NewPersonaExternalMemoryRef, NewPersonaFact, NewPersonaHabitPattern, NewPersonaInteractionMemory, NewPersonaLifecycleEffect, NewPersonaMemoryEmbedding, NewPersonaMoodState, NewPersonaProfile, NewPersonaSemanticBelief, NewPersonaSourceChunk, NewPersonaSourceDocument, NewPersonaStyleProfile, NewPersonaWorkspaceState, PERSONA_ALIAS_STATES, PERSONA_ALIAS_SURFACES, PERSONA_BELIEF_STANCES, PERSONA_BELIEF_TYPES, PERSONA_CONSENT_STATUSES, PERSONA_EMBEDDING_DIMENSION, PERSONA_EMBEDDING_TARGET_KINDS, PERSONA_EXTERNAL_MEMORY_LOCAL_TARGET_KINDS, PERSONA_EXTERNAL_MEMORY_PROVIDERS, PERSONA_EXTERNAL_MEMORY_REF_STATES, PERSONA_FACT_OBJECT_TYPES, PERSONA_FACT_TYPES, PERSONA_INTERACTION_MEMORY_STATES, PERSONA_LIFECYCLE_EFFECT_STATUSES, PERSONA_LIFECYCLE_EFFECT_TYPES, PERSONA_MEMORY_STATES, PERSONA_PRIVACY_LEVELS, PERSONA_PROFILE_STATES, PERSONA_PROFILE_TYPES, PERSONA_RIGHTS_STATUSES, PERSONA_SCOPES, PERSONA_SOURCE_PRIORITIES, PERSONA_SOURCE_TYPES, PersonaAlias, PersonaAliasState, PersonaAliasSurface, PersonaAuditLog, PersonaBeliefStance, PersonaBeliefType, PersonaConsentStatus, PersonaEmbeddingTargetKind, PersonaEmotionAnnotation, PersonaEmotionalSalience, PersonaEpisodeMemory, PersonaExternalMemoryAudit, PersonaExternalMemoryCandidate, PersonaExternalMemoryLocalTargetKind, PersonaExternalMemoryProvider, PersonaExternalMemoryRef, PersonaExternalMemoryRefState, PersonaFact, PersonaFactObjectType, PersonaFactType, PersonaHabitPattern, PersonaInteractionMemory, PersonaInteractionMemoryState, PersonaLifecycleEffect, PersonaLifecycleEffectStatus, PersonaLifecycleEffectType, PersonaLocationMetadata, PersonaMemoryEmbedding, PersonaMemoryRetrievalCandidateKind, PersonaMemoryRetrievalCandidateScore, PersonaMemoryRetrievalPayload, PersonaMemoryRetrievalQueryKind, PersonaMemoryRetrievalScoreComponents, PersonaMemoryState, PersonaMoodState, PersonaPersonRef, PersonaPrivacyLevel, PersonaProfile, PersonaProfilePolicy, PersonaProfileState, PersonaProfileType, PersonaRightsStatus, PersonaScope, PersonaSemanticBelief, PersonaSourceChunk, PersonaSourceDocument, PersonaSourceMetadata, PersonaSourcePriority, PersonaSourceRef, PersonaSourceType, PersonaStyleProfile, PersonaTimeMetadata, PersonaToneVector, PersonaWorkspacePayload, PersonaWorkspaceState, personaAliases, personaAuditLogs, personaEmotionalSalience, personaEpisodeMemories, personaExternalMemoryRefs, personaFacts, personaHabitPatterns, personaInteractionMemories, personaLifecycleEffects, personaMemoryEmbeddings, personaMoodStates, personaProfiles, personaSemanticBeliefs, personaSourceChunks, personaSourceDocuments, personaStyleProfiles, personaWorkspaceStates } from './schema/index.js';
+export { D as DisclosurePolicy, P as PERSONA_ANSWER_MODES, a as PERSONA_MEMORY_TYPES, b as PERSONA_QUERY_TYPES, c as PersonaAffectVector, d as PersonaAnswerMode, e as PersonaContextGatewayOutput, f as PersonaEmbedder, g as PersonaGateOutput, h as PersonaJsonLlm, i as PersonaLogger, j as PersonaMemoryCandidate, k as PersonaMemorySelectionResult, l as PersonaMemoryTriageDecision, m as PersonaMemoryTriageIntent, n as PersonaMemoryTriageSource, o as PersonaMemoryTriageType, p as PersonaMemoryType, q as PersonaMoodEmotionLabel, r as PersonaMoodEmotionLabelSource, s as PersonaMoodSignal, t as PersonaMoodUpdateTrace, u as PersonaQueryType, v as PersonaRuntimeContext, w as PersonaTurnAffectEstimate, x as PersonaTurnPlan } from './types-BHEW4MGH.js';
+import 'drizzle-orm/postgres-js';
+import 'drizzle-orm/pg-core';