@vertesia/common 1.0.0-dev.20260128.144200 → 1.0.0-dev.20260225.024852Z

package/src/project.ts

@@ -1,4 +1,5 @@
 import { SupportedIntegrations } from "./integrations.js";
+import { ContentObjectTypeRef } from "./store/store.js";
 import { AccountRef } from "./user.js";
 
 export interface ICreateProjectPayload {
@@ -183,6 +184,29 @@ export interface ProjectConfiguration {
      */
     agent_streaming_enabled?: boolean;
 
+    /**
+     * Indexing configuration for this project.
+     * Controls whether indexing and querying are enabled at the project level.
+     */
+    indexing?: {
+        /**
+         * Enable indexing for content objects in this project.
+         * When enabled, content changes trigger indexing workflows.
+         * Defaults to true - indexing is always on when ES infrastructure is available.
+         */
+        enabled?: boolean;
+    };
+
+    /**
+     * Primary language for full-text search analysis.
+     * ISO 639-1 code (e.g., 'en', 'fr', 'ja', 'de').
+     * Determines which Elasticsearch analyzer is used for the text field.
+     * Defaults to 'en' (English/standard analyzer).
+     *
+     * Changing this value requires a full reindex to take effect.
+     */
+    main_language?: string;
+
 }
 
 // export interface ProjectConfigurationEmbeddings {
@@ -246,7 +270,6 @@ export const ProjectRefPopulate = "id name account";
 export interface EmbeddingsStatusResponse {
     status: string;
     embeddingRunsInProgress?: number;
-    totalRunsInProgress?: number;
     totalIndexableObjects?: number;
     embeddingsModels?: string[];
     objectsWithEmbeddings?: number;
@@ -257,6 +280,291 @@ export interface EmbeddingsStatusResponse {
     }
 }
 
+/**
+ * Response from indexing status endpoint
+ */
+export interface IndexingStatusResponse {
+    /** Whether indexing infrastructure is available globally */
+    infrastructureEnabled: boolean;
+    /** Whether indexing is enabled for this project */
+    indexingEnabled: boolean;
+    /** @deprecated Now derived from indexingEnabled - queries automatically route to index when indexing is enabled */
+    query_enabled: boolean;
+    /** Index status */
+    index: {
+        /** Whether the index exists */
+        exists: boolean;
+        /** Alias name (used for queries) */
+        aliasName: string;
+        /** Actual index name (versioned) */
+        indexName: string;
+        /** Index version (timestamp when created) */
+        version: number;
+        /** When the current index was created */
+        createdAt: string | null;
+        /** Number of documents in the index */
+        documentCount: number;
+        /** Index size in bytes */
+        sizeBytes: number;
+    };
+    /** MongoDB document count for comparison */
+    mongoDocumentCount: number;
+    /** Whether a reindex is currently in progress */
+    reindexInProgress: boolean;
+    /** Reindex progress (if reindex is in progress) */
+    reindexProgress?: {
+        /** Total documents to reindex */
+        total: number;
+        /** Documents processed so far */
+        processed: number;
+        /** Successfully indexed documents */
+        successful: number;
+        /** Failed documents */
+        failed: number;
+        /** Current status (e.g., "indexing", "complete") */
+        status: string;
+        /** Current batch number */
+        currentBatch: number;
+        /** Total number of batches */
+        totalBatches: number;
+        /** Percentage complete (0-100) */
+        percentComplete: number;
+        /** Batches processed per second */
+        batchesPerSecond: number;
+        /** Documents processed per second */
+        docsPerSecond: number;
+        /** Elapsed time in seconds */
+        elapsedSeconds: number;
+        /** Estimated seconds remaining (null if unknown) */
+        estimatedSecondsRemaining: number | null;
+    };
+}
+
+// ============================================================================
+// Internal indexing types (used by Temporal workflows)
+// ============================================================================
+
+/**
+ * Document data structure for Elasticsearch indexing
+ */
+export interface ElasticsearchDocumentData {
+    name?: string;
+    text?: string;
+    properties?: Record<string, unknown>;
+    status?: string;
+    type?: ContentObjectTypeRef;
+    security?: {
+        'content:read'?: string[];
+        'content:write'?: string[];
+        'content:delete'?: string[];
+    };
+    revision?: {
+        head?: boolean;
+        root?: string;
+    };
+    embeddings_text?: number[];
+    embeddings_image?: number[];
+    embeddings_properties?: number[];
+    created_at?: Date | string;
+    updated_at?: Date | string;
+}
+
+/**
+ * Result from bulk indexing
+ */
+export interface BulkIndexResult {
+    successful: number;
+    failed: number;
+}
+
+/**
+ * Result from creating a reindex target
+ */
+export interface CreateReindexTargetResult {
+    created: boolean;
+    indexName: string;
+    aliasName: string;
+    version: number;
+}
+
+/**
+ * Result from getting reindex range
+ */
+export interface ReindexRangeResult {
+    first: string | null;
+    last: string | null;
+    count: number;
+}
+
+/**
+ * Result from fetching a batch
+ */
+export interface FetchBatchResult {
+    documents: Array<{
+        id: string;
+        document: ElasticsearchDocumentData;
+    }>;
+    nextCursor: string | null;
+    done: boolean;
+}
+
+/**
+ * Result from indexing a batch
+ */
+export interface IndexBatchResult {
+    successful: number;
+    failed: number;
+    processed: number;
+    nextCursor: string | null;
+    done: boolean;
+}
+
+/**
+ * Result from triggering a reindex
+ */
+export interface TriggerReindexResult {
+    status: string;
+    workflow?: string;
+    workflowId?: string;
+    runId?: string;
+    objectCount?: number;
+    reason?: string;
+    enabled?: boolean;
+}
+
+/**
+ * Elasticsearch index statistics
+ */
+export interface ElasticsearchIndexStats {
+    enabled: boolean;
+    exists?: boolean;
+    documentCount?: number;
+    sizeInBytes?: number;
+    indexName?: string;
+    aliasName?: string;
+}
+
+/**
+ * Embedding configuration for a single type
+ */
+export interface EmbeddingTypeConfig {
+    environment?: string;
+    dimensions?: number;
+    model?: string;
+    provider?: string;
+    enabled?: boolean;
+}
+
+/**
+ * Detailed index configuration
+ */
+export interface IndexConfiguration {
+    enabled: boolean;
+    exists?: boolean;
+    indexName?: string;
+    aliasName?: string;
+    version?: number;
+    documentCount?: number;
+    sizeInBytes?: number;
+    embeddingDimensions?: {
+        text?: number;
+        image?: number;
+        properties?: number;
+    };
+    /** ISO 639-1 language code for text analysis */
+    language?: string;
+    fieldMappings?: Record<string, unknown>;
+    projectEmbeddingsConfig?: {
+        text?: EmbeddingTypeConfig;
+        image?: EmbeddingTypeConfig;
+        properties?: EmbeddingTypeConfig;
+    };
+    createdAt?: Date | null;
+}
+
+/**
+ * Supported languages for full-text search with their display names.
+ * Maps ISO 639-1 codes to human-readable language names.
+ */
+export const SUPPORTED_SEARCH_LANGUAGES: Record<string, string> = {
+    en: 'English',
+    zh: 'Chinese',
+    es: 'Spanish',
+    hi: 'Hindi',
+    ar: 'Arabic',
+    pt: 'Portuguese',
+    bn: 'Bengali',
+    ru: 'Russian',
+    ja: 'Japanese',
+    de: 'German',
+    fr: 'French',
+    ko: 'Korean',
+    it: 'Italian',
+    tr: 'Turkish',
+    vi: 'Vietnamese',
+    pl: 'Polish',
+    uk: 'Ukrainian',
+    nl: 'Dutch',
+    th: 'Thai',
+    el: 'Greek',
+    cs: 'Czech',
+    sv: 'Swedish',
+    ro: 'Romanian',
+    hu: 'Hungarian',
+    da: 'Danish',
+    fi: 'Finnish',
+    no: 'Norwegian',
+    he: 'Hebrew',
+    id: 'Indonesian',
+    fa: 'Persian',
+};
+
+/**
+ * Result from fetching documents by IDs
+ */
+export interface FetchDocumentsByIdsResult {
+    documents: Array<{
+        id: string;
+        document: ElasticsearchDocumentData;
+    }>;
+    notFound: string[];
+}
+
+/**
+ * Result from bulk delete
+ */
+export interface BulkDeleteResult {
+    successful: number;
+    failed: number;
+}
+
+/**
+ * Result from ensure index operation
+ */
+export interface EnsureIndexResult {
+    created: boolean;
+    recreated?: boolean;
+    existed?: boolean;
+    enabled?: boolean;
+    status?: string;
+    dimensions?: {
+        text?: number;
+        image?: number;
+        properties?: number;
+    };
+    language?: string;
+}
+
+/**
+ * Result from swap alias operation
+ */
+export interface SwapAliasResult {
+    swapped: boolean;
+    aliasName?: string;
+    newIndexName?: string;
+    reason?: string;
+}
+
 export interface ProjectIntegrationListEntry {
     id: SupportedIntegrations;
     enabled: boolean;

package/src/prompt.ts

@@ -1,6 +1,5 @@
-import type { JSONObject } from "@llumiverse/common";
+import type { JSONObject, JSONSchema } from "@llumiverse/common";
 import { PromptRole } from "@llumiverse/common";
-import type { JSONSchema4 } from "json-schema";
 import { ProjectRef } from "./project.js";
 
 export interface ChatPromptSchema {
@@ -49,7 +48,7 @@ export interface PromptTemplateRef {
 }
 
 export interface PromptTemplateRefWithSchema extends PromptTemplateRef {
-    inputSchema?: JSONSchema4;
+    inputSchema?: JSONSchema;
 }
 
 export enum TemplateType {
@@ -61,7 +60,7 @@ export interface ExecutablePromptTemplate {
     role: PromptRole;
     content: string;
     content_type: TemplateType;
-    inputSchema?: JSONSchema4;
+    inputSchema?: JSONSchema;
 }
 export interface PromptTemplate extends ExecutablePromptTemplate {
     id: string;

package/src/skill.ts

@@ -10,6 +10,7 @@
  * These are automatically synced to the sandbox when the skill is used.
  */
 
+
 /**
  * Context provided when searching for relevant skills
  */

package/src/store/conversation-state.ts

@@ -127,6 +127,15 @@ export interface ConversationState {
      * When a skill is called, its related tools are added to unlocked_tools.
      */
     skill_tool_map?: Record<string, string[]>;
+
+    /**
+     * Current activity group ID for internal tool-execution progress messages.
+     * All updates emitted during one tool-execution cycle should share this ID.
+     */
+    active_activity_group_id?: string;
+
+    /** LLM stop reason from the latest call (e.g., "stop", "length", "tool_use") */
+    finish_reason?: string;
 }
 
 /** Skill metadata collected at workflow start for upfront sandbox hydration */

package/src/store/doc-analyzer.ts

@@ -1,7 +1,7 @@
 import { WorkflowExecutionPayload, WorkflowRunStatus } from "./workflow.js";
 
 export interface PdfToRichtextOptions {
-    features: string[];
+    features?: string[];
     debug?: boolean;
     [key: string]: any;
 }

package/src/store/dsl-workflow.ts

@@ -3,6 +3,26 @@ import { BaseObject } from "./common.js";
 import { WorkflowExecutionPayload } from "./index.js";
 import { ParentClosePolicyType } from "./temporalio.js";
 
+/**
+ * Discriminator for workflow input type - either object IDs or GCS file URIs
+ */
+export type WorkflowInputType = 'objectIds' | 'files';
+
+/**
+ * File reference with URL and mimetype
+ */
+export interface WorkflowInputFile {
+    url: string;
+    mimetype: string;
+}
+
+/**
+ * Discriminated union for workflow inputs.
+ * Workflows can accept either a list of object IDs (existing behavior) OR a list of file references (new).
+ */
+export type WorkflowInput =
+    | { inputType: 'objectIds', objectIds: string[] }
+    | { inputType: 'files', files: WorkflowInputFile[] };
 
 /**
  * The payload sent when starting a workflow from the temporal client to the workflow instance.
@@ -190,6 +210,12 @@ export interface DSLChildWorkflowStep extends DSLWorkflowStepBase {
      * since it may contain references to workflow execution vars.
      */
     output?: string;
+    /**
+     * A JSON expression which evaluates to true or false similar to mongo matches.
+     * The child workflow will only execute if the condition is satisfied.
+     * Example: {$eq: {wfVarName: value}}
+     */
+    condition?: Record<string, any>;
     /**
      * In case the dslWorkflow is used as a child workflow the spec is used to define the child workflow.
      * If spec is defined then the name must be "dslWorkflow"

package/src/store/hive-memory.ts

@@ -0,0 +1,167 @@
+import { BaseObject } from "./common.js";
+
+/**
+ * Tool recommendation within a hive memory unit
+ */
+export interface HiveMemoryToolRecommendation {
+    tool_name: string;
+    guidance: string;
+}
+
+/**
+ * Memory unit scope - project-scoped by default, can be elevated to account
+ */
+export type HiveMemoryScope = 'project' | 'account';
+
+/**
+ * Base interface for hive memory items (list/summary view)
+ */
+export interface HiveMemoryItem extends BaseObject {
+    // Classification
+    task_category: string;  // "document-analysis", "data-extraction", etc.
+    domain?: string;        // "financial", "legal", etc.
+
+    // Summary
+    summary: string;
+
+    // Tools involved in the learnings
+    tools_involved: string[];
+
+    // Quality metrics
+    confidence_score: number;     // 0-1
+    usage_count: number;
+    success_correlation: number;  // correlation with successful runs
+    contribution_count: number;   // number of runs that contributed
+
+    // Scoping
+    scope: HiveMemoryScope;
+}
+
+/**
+ * Full hive memory unit with all learnings and patterns
+ */
+export interface HiveMemory extends HiveMemoryItem {
+    // Objective patterns this memory applies to
+    objective_patterns: string[];
+
+    // Learnings
+    general_learnings: string[];
+    best_practices: string[];
+    pitfalls_to_avoid: string[];
+    tool_recommendations: HiveMemoryToolRecommendation[];
+
+    // Vector search
+    embedding?: number[];
+
+    // Security field for granular permissions
+    security?: Record<string, string[]>;
+}
+
+/**
+ * Payload for creating a new hive memory unit
+ */
+export interface CreateHiveMemoryPayload {
+    // Classification
+    task_category: string;
+    domain?: string;
+
+    // Content
+    summary: string;
+    objective_patterns: string[];
+
+    // Learnings
+    general_learnings: string[];
+    best_practices?: string[];
+    pitfalls_to_avoid?: string[];
+    tool_recommendations?: HiveMemoryToolRecommendation[];
+
+    // Metadata
+    tools_involved?: string[];
+
+    // Quality (optional, defaults applied)
+    confidence_score?: number;
+
+    // Scoping
+    scope?: HiveMemoryScope;
+
+    // Standard fields
+    name?: string;
+    description?: string;
+    tags?: string[];
+}
+
+/**
+ * Payload for updating an existing hive memory unit
+ */
+export interface UpdateHiveMemoryPayload {
+    // Classification updates
+    task_category?: string;
+    domain?: string;
+
+    // Content updates
+    summary?: string;
+
+    // Array additions (merged with existing)
+    add_objective_patterns?: string[];
+    add_general_learnings?: string[];
+    add_best_practices?: string[];
+    add_pitfalls_to_avoid?: string[];
+    add_tool_recommendations?: HiveMemoryToolRecommendation[];
+    add_tools_involved?: string[];
+
+    // Quality updates
+    confidence_score?: number;
+    increment_usage_count?: boolean;
+    increment_contribution_count?: boolean;
+    success_correlation?: number;
+
+    // Scoping
+    scope?: HiveMemoryScope;
+
+    // Standard fields
+    name?: string;
+    description?: string;
+    tags?: string[];
+}
+
+/**
+ * Search parameters for finding relevant memories
+ */
+export interface HiveMemorySearchParams {
+    // Semantic search
+    query?: string;              // Natural language query
+    embedding?: number[];        // Pre-computed embedding for vector search
+
+    // Filters
+    task_category?: string;
+    domain?: string;
+    tools_involved?: string[];
+    scope?: HiveMemoryScope;
+    min_confidence?: number;     // Minimum confidence score (0-1)
+
+    // Pagination
+    limit?: number;              // Default: 5
+    offset?: number;
+}
+
+/**
+ * Response from memory search
+ */
+export interface HiveMemorySearchResult {
+    memories: HiveMemory[];
+    total: number;
+}
+
+/**
+ * Formatted memory for agent consumption
+ */
+export interface FormattedMemoryForAgent {
+    category: string;
+    domain?: string;
+    summary: string;
+    learnings: string[];
+    best_practices: string[];
+    pitfalls_to_avoid: string[];
+    tool_guidance: { tool: string; guidance: string }[];
+    confidence: number;
+}

package/src/store/index.ts

@@ -4,10 +4,12 @@ export * from "./common.js";
 export * from "./conversation-state.js";
 export * from "./doc-analyzer.js";
 export * from "./dsl-workflow.js";
+export * from "./hive-memory.js";
 export * from "./object-types.js";
 export * from "./schedule.js";
 export * from "./signals.js";
 export * from "./store.js";
+export * from "./rendering.js";
 export * from "./temporalio.js";
 export * from "./worker.js";
 export * from "./workflow.js";