@rizom/site-rizom-ai 0.2.0-alpha.259 → 0.2.0-alpha.261

package/dist/index.d.ts

@@ -474,6 +474,20 @@ type AssetRecord = z.output<typeof assetRecordSchema>;
 type EntityIdPath = [string, ...string[]];
 type EntityIdPathInput = readonly [string, ...string[]];
 //#endregion
+//#region ../../shared/contracts/src/ask-box.d.ts
+/**
+ * Dispatched on the host (bubbling) once an answer completes: which public
+ * sources it drew on, keyed `entityType:entityId`. A host page may use it,
+ * for example to show where those sources sit; it never affects the box.
+ * Each source the mounted box lists carries ASK_SOURCE_ATTRIBUTE with the
+ * same key, so a host can point at it.
+ */
+/** The brain whose published memory a source came from: its name, and its address when it has one. */
+declare const sourceBrainSchema: z.ZodObject<{
+  name: z.ZodString;
+  url: z.ZodOptional<z.ZodString>;
+}>;
+//#endregion
 //#region ../../shared/contracts/src/guest-execution.d.ts
 type Strict$1<Shape extends z.ZodRawShape> = z.ZodObject<Shape, z.core.$strict>;
 /** Server-owned limits, not a browser's requested model settings. */
@@ -515,6 +529,38 @@ declare const guestTurnSettlementSchema: Strict$1<{
   usage: typeof guestTurnUsageSchema;
   cost: typeof guestTurnCostSchema;
 }>;
+/**
+ * What a guest turn screens a visitor's question against, passed in by the
+ * box's host beside its execution limits: the brain's public topics and the
+ * owner's introduction as the site's scope, and the refusal a screened-out
+ * visitor reads, in the site's words.
+ */
+declare const guestScreeningSchema: Strict$1<{
+  topics: z.ZodArray<z.ZodString>;
+  introduction: z.ZodOptional<z.ZodString>;
+  refusal: z.ZodOptional<z.ZodString>;
+}>;
+type GuestScreening = z.output<typeof guestScreeningSchema>;
+/** The categories that refuse a question. */
+declare const guestRefusalCategorySchema: z.ZodEnum<{
+  "off-topic": "off-topic";
+  abusive: "abusive";
+  injection: "injection";
+  harmful: "harmful";
+}>;
+/**
+ * What screening did with a guest turn: answered after an in-scope judgment,
+ * refused with the category it was judged, or answered unscreened because
+ * the judgment failed.
+ */
+declare const guestScreeningOutcomeSchema: z.ZodDiscriminatedUnion<[Strict$1<{
+  outcome: z.ZodLiteral<"answered">;
+}>, Strict$1<{
+  outcome: z.ZodLiteral<"refused">;
+  category: typeof guestRefusalCategorySchema;
+}>, Strict$1<{
+  outcome: z.ZodLiteral<"unscreened">;
+}>], "outcome">;
 //#endregion
 //#region ../../shared/contracts/src/agent-response.d.ts
 type PendingConfirmationSchema = z.ZodObject<{
@@ -583,6 +629,7 @@ type SourceCitationSchema = z.ZodObject<{
   entityId: z.ZodOptional<z.ZodString>;
   excerpt: z.ZodOptional<z.ZodString>;
   provenance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  brain: z.ZodOptional<typeof sourceBrainSchema>;
 }>;
 declare const SourceCitationSchema: SourceCitationSchema;
 type SourcesCardSchema = z.ZodObject<{
@@ -646,6 +693,11 @@ type AgentResponseSchema = z.ZodObject<{
   pendingConfirmations: z.ZodOptional<z.ZodArray<PendingConfirmationSchema>>;
   usage: AgentResponseUsageSchema;
   guestSettlement: z.ZodOptional<typeof guestTurnSettlementSchema>;
+  guestScreening: z.ZodOptional<typeof guestScreeningOutcomeSchema>;
+  askedBefore: z.ZodOptional<AskedBeforeSchema>;
+}>;
+type AskedBeforeSchema = z.ZodObject<{
+  faqId: z.ZodString;
 }>;
 declare const AgentResponseSchema: AgentResponseSchema;
 type AgentResponse = z.output<typeof AgentResponseSchema>;
@@ -1173,6 +1225,8 @@ declare class ProjectionStore {
   transferEntityAuthority<TResult>(input: ProjectionOwnedEntityInput, mutation: (transaction: EntityTransaction) => Promise<TResult>): Promise<TResult>;
   markDirty(input: MarkProjectionDirtyInput): Promise<number>;
   withDirtyInput<TResult>(input: MarkProjectionDirtyInput, mutation: (transaction: EntityTransaction) => Promise<TResult>): Promise<TResult>;
+  /** Commit all dirty inputs with their mutation in one batch-owned transaction. */
+  withDirtyInputs<TResult>(inputs: readonly MarkProjectionDirtyInput[], mutation: (transaction: EntityTransaction) => Promise<TResult>): Promise<TResult>;
   listPendingInputs(): Promise<ProjectionDirtyInput[]>;
   hasActiveProjectionBatch(): Promise<boolean>;
   claimPendingWave(input: ClaimProjectionWaveInput): Promise<ProjectionWave | null>;
@@ -1198,6 +1252,20 @@ interface EntityWriteCondition {
   expectedRevision: string | null;
 }
 //#endregion
+//#region ../../shell/entity-service/src/entity-mutation-receipt.d.ts
+/** Native-only durable mutation identity, scoped by the admitted caller. */
+interface EntityMutationReceiptKey {
+  namespace: string;
+  key: string;
+}
+type EntityMutationReceipt = {
+  operation: "none";
+} | {
+  operation: "create" | "update";
+  entityType: string;
+  entityId: string;
+};
+//#endregion
 //#region ../../shell/entity-service/src/types.d.ts
 /**
  * Options for entity mutation operations (create, update, upsert)
@@ -1210,6 +1278,22 @@ interface EntityMutationEventContext {
   actor?: ActorRef;
   interfaceType?: string;
 }
+/** First committed result wins, even if retries choose a different destination.
+ * Receipts survive destination edits, folds and deletion. Transaction retries
+ * never replay callbacks; validation can still run in separate attempts.
+ * A content conflict does not consume the identity. This is not an author SDK API.
+ */
+type ApplyEntityMutationOnceRequest = {
+  receipt: EntityMutationReceiptKey;
+} & ({
+  operation: "none";
+} | {
+  operation: "create";
+  request: CreateEntityRequest<BaseEntity>;
+} | {
+  operation: "update";
+  request: UpdateEntityRequest<BaseEntity>;
+});
 interface EntityWriteSnapshot {
   entity: BaseEntity;
   revision: string;
@@ -1492,6 +1576,8 @@ interface SortField {
   direction: "asc" | "desc";
   /** Sort NULL values before non-NULL values (default: false / SQLite default) */
   nullsFirst?: boolean;
+  /** Sort NULL values after non-NULL values, whatever the direction */
+  nullsLast?: boolean;
 }
 /**
  * List entities options
@@ -1552,6 +1638,11 @@ interface EntityTypeConfig {
   /** Whether to index serialized content in full-text search (default: true).
    *  Set to false for binary entity types. Mutations remove stale FTS rows. */
   fullTextSearchable?: boolean;
+  /** Whether a search that names no entity types includes this type (default: true).
+   *  Set to false for entities derived from the brain's own answers, so they are
+   *  not retrieved as sources; a search naming the type still finds them, and
+   *  raw-distance search is unaffected. */
+  includeInBroadSearch?: boolean;
   /** Binary storage policy. Absence means text content. */
   binaryStorage?: "data-url" | "asset";
   /** Default system_list order, applied by the entity service before pagination. */
@@ -1655,10 +1746,27 @@ interface UpdateEntityRequest<T extends BaseEntity> {
   preparedAsset?: PreparedAsset | undefined;
   options?: UpdateEntityOptions | undefined;
 }
+/** Native-only atomic same-type, same-visibility update and removal.
+ * Both revisions must come from admitted write snapshots. The source is
+ * removed only when the destination and both journals commit with it.
+ */
+interface FoldEntityRequest<T extends BaseEntity = BaseEntity> {
+  source: {
+    entityType: string;
+    id: string;
+    expectedRevision: string;
+  };
+  targetRevision: string;
+  entity: T;
+  options?: Omit<UpdateEntityOptions, "conditionalWrite" | "expectedContentHash">;
+}
 interface DeleteEntityRequest {
   entityType: string;
   id: string;
-  options?: Pick<EntityJobOptions, "eventContext" | "persistenceOrigin"> | undefined;
+  options?: (Pick<EntityJobOptions, "eventContext" | "persistenceOrigin"> & {
+    /** Delete only while the stored entity still has this content hash; false otherwise. */
+    expectedContentHash?: string | undefined;
+  }) | undefined;
 }
 interface UpsertEntityRequest<T extends BaseEntity> {
   entity: T;
@@ -1675,6 +1783,10 @@ interface EntitySearchRequest {
 }
 interface SearchWithDistancesRequest {
   query: string;
+  /** Only these entity types; empty or omitted includes all types. */
+  types?: string[] | undefined;
+  /** Only results at most this cosine distance from the query. */
+  maxDistance?: number | undefined;
 }
 interface SemanticEntityReference {
   entityId: string;
@@ -1897,6 +2009,9 @@ interface EntityServiceClient extends ICoreEntityService {
   createEntityFromMarkdown(request: CreateEntityFromMarkdownRequest): Promise<EntityMutationResult>;
   updateEntity<T extends BaseEntity>(request: UpdateEntityRequest<T>): Promise<EntityMutationResult>;
   deleteEntity(request: DeleteEntityRequest): Promise<boolean>;
+  foldEntity(request: FoldEntityRequest): Promise<EntityMutationResult>;
+  getEntityMutationReceipt(key: EntityMutationReceiptKey): Promise<EntityMutationReceipt | null>;
+  applyEntityMutationOnce(request: ApplyEntityMutationOnceRequest): Promise<EntityMutationReceipt>;
   upsertEntity<T extends BaseEntity>(request: UpsertEntityRequest<T>): Promise<EntityMutationResult & {
     created: boolean;
   }>;
@@ -2385,7 +2500,10 @@ interface IJobQueueService {
   getDiagnostics(now?: number): Promise<JobQueueDiagnostics>;
   /** Settle once nothing is in flight and nothing new has arrived. */
   waitForIdle(options?: JobQueueIdleOptions): Promise<void>;
-  /** Read durable processing and terminal updates for web-owned publication. */
+  /**
+   * Read one durable update page after the cursor for web-owned publication.
+   * Limit must be an integer from 0 to 1,000 (default 1,000); zero returns no rows.
+   */
   getRuntimeUpdates(cursor: JobRuntimeUpdateCursor, limit?: number): Promise<JobRuntimeUpdate[]>;
   /**
    * Clean up old completed jobs
@@ -3639,6 +3757,8 @@ type ChatAttachment = TextChatAttachment | FileChatAttachment;
 interface ChatContext {
   /** Server-owned limits bound to the already-reserved guest execution. */
   guestExecution?: GuestExecutionPolicy;
+  /** The site's scope and refusal copy a guest question is screened against. */
+  guestScreening?: GuestScreening;
   userPermissionLevel?: UserPermissionLevel;
   /** Whether the authenticated caller is the brain's configured Anchor. */
   isAnchor?: boolean;