@wildo-ai/saas-models 1.0.1

package/dist/esm/flows-actors/actors.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actors.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EAAuE,oBAAoB,EAA0B,MAAM,sCAAsC,CAAC;AAezK,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,iBAAiB,sBAAsB;IACvC,cAAc,oBAAoB;CACnC;AAGD,oBAAY,mBAAmB;IAC7B,OAAO,YAAY;IACnB,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;CACxC;AAED,eAAO,MAAM,WAAW;;;;;;;uCAOtB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAMhD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAG5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAwBtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/esm/flows-actors/actors.shared.schemas.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { WildoError_BackendSchema } from "../errors/errors.shared.schemas.js";
+import { FlowsActors_Status } from "./flows-actors.commons.shared.schemas.js";
+import { FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, FlowActorSystemSchema, } from "./flows-actors.system.shared.schemas.js";
+import { Actors_Task_Schema, Actors_Walkthrough_Schema, ActorsSystem_ExecutionPlan_Schema } from "./tasks.actors.shared.schemas.js";
+//===============================================================
+//  Actor
+// --------
+// Actors are reactive components that subscribe to event topics
+// and respond with automated processing. They enable event-driven
+// architecture by processing messages asynchronously, supporting
+// batch processing, filtering, and various error handling strategies.
+// Actors can emit new events, creating event chains and workflows.
+//===============================================================
+export var Actor_Role_Category;
+(function (Actor_Role_Category) {
+    Actor_Role_Category["COORDINATOR"] = "coordinator";
+    Actor_Role_Category["TASK_PLANNER"] = "task_planner";
+    Actor_Role_Category["OPERATOR"] = "operator";
+    Actor_Role_Category["ANALYZER"] = "analyzer";
+    Actor_Role_Category["REVIEWER"] = "reviewer";
+    Actor_Role_Category["HUMAN_IN_THE_LOOP"] = "human_in_the_loop";
+    Actor_Role_Category["FLOW_EXECUTION"] = "flow_exectution";
+})(Actor_Role_Category || (Actor_Role_Category = {}));
+export var Actor_ExecutionMode;
+(function (Actor_ExecutionMode) {
+    Actor_ExecutionMode["AGENTIC"] = "agentic";
+    Actor_ExecutionMode["FLOW_EXECUTION"] = "flow_execution";
+    Actor_ExecutionMode["HUMAN_INTERACTION"] = "human_interaction";
+})(Actor_ExecutionMode || (Actor_ExecutionMode = {}));
+export const ActorSchema = z.object({
+    ref: z.string().min(1),
+    displayName: z.string().min(1),
+    roleCategory: z.enum(Actor_Role_Category),
+    executionMode: z.enum(Actor_ExecutionMode),
+    agentRef: z.string().optional(),
+    flowRef: z.string().optional(),
+});
+//===============================================================
+//  Actor System
+//===============================================================
+export const ActorSystemSchema = FlowActorSystemSchema.extend({
+    type: z.literal(FlowActorSystem_Kind.ACTOR),
+    actors: z.array(z.lazy(() => ActorSchema)),
+});
+//===============================================================
+//  Actor System Execution
+//===============================================================
+export const ActorSystem_ExecutionSchema = FlowActorSystem_ExecutionSchema.extend({
+    kind: z.literal(FlowActorSystem_Kind.ACTOR),
+    plan: ActorsSystem_ExecutionPlan_Schema.optional(),
+    walkthrough: Actors_Walkthrough_Schema.optional(),
+    standaloneTasks: z.array(Actors_Task_Schema),
+    standaloneTaskStates: z.object({
+        taskId: z.string(),
+        status: z.enum(FlowsActors_Status),
+        updatedAt: z.iso.datetime(),
+        statusChanges: z.array(z.object({
+            status: z.enum(FlowsActors_Status),
+            timestamp: z.iso.datetime(),
+        })),
+    }).array(),
+    errorStates: FlowActorSystem_ErrorStates_Schema.extend({
+        errors: WildoError_BackendSchema.extend({
+            systemRef: z.string(),
+            taskId: z.string().optional(),
+            planStepId: z.string().optional(),
+        }).array().optional(),
+    }).optional(),
+});
+//# sourceMappingURL=actors.shared.schemas.js.map

package/dist/esm/flows-actors/actors.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actors.shared.schemas.js","sourceRoot":"","sources":["../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EAAE,kCAAkC,EAAE,+BAA+B,EAAE,oBAAoB,EAAE,qBAAqB,GAAG,MAAM,sCAAsC,CAAC;AACzK,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,iCAAiC,EAAE,MAAM,+BAA+B,CAAC;AAGjI,iEAAiE;AACjE,SAAS;AACT,WAAW;AACX,gEAAgE;AAChE,kEAAkE;AAClE,iEAAiE;AACjE,sEAAsE;AACtE,mEAAmE;AACnE,iEAAiE;AAGjE,MAAM,CAAN,IAAY,mBAQX;AARD,WAAY,mBAAmB;IAC7B,kDAA2B,CAAA;IAC3B,oDAA6B,CAAA;IAC7B,4CAAqB,CAAA;IACrB,4CAAqB,CAAA;IACrB,4CAAqB,CAAA;IACrB,8DAAuC,CAAA;IACvC,yDAAkC,CAAA;AACpC,CAAC,EARW,mBAAmB,KAAnB,mBAAmB,QAQ9B;AAGD,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC7B,0CAAmB,CAAA;IACnB,wDAAiC,CAAA;IACjC,8DAAuC,CAAA;AACzC,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAED,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACtB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC;IACzC,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC;IAC1C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAGH,iEAAiE;AACjE,gBAAgB;AAChB,iEAAiE;AAEjE,MAAM,CAAC,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,CAAC;IAC5D,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC;IAC3C,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC;CAC3C,CAAC,CAAC;AAIH,iEAAiE;AACjE,0BAA0B;AAC1B,iEAAiE;AAEjE,MAAM,CAAC,MAAM,2BAA2B,GAAG,+BAA+B,CAAC,MAAM,CAAC;IAChF,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC;IAE3C,IAAI,EAAE,iCAAiC,CAAC,QAAQ,EAAE;IAClD,WAAW,EAAE,yBAAyB,CAAC,QAAQ,EAAE;IACjD,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;IAE5C,oBAAoB,EAAE,CAAC,CAAC,MAAM,CAAC;QAC7B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;QAClB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC;QAClC,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE;QAC3B,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;YAC9B,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC;YAClC,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE;SAC5B,CAAC,CAAC;KACJ,CAAC,CAAC,KAAK,EAAE;IAEV,WAAW,EAAG,kCAAkC,CAAC,MAAM,CAAC;QACtD,MAAM,EAAE,wBAAwB,CAAC,MAAM,CAAC;YACtC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;YACrB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAC7B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;SAClC,CAAC,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;KACtB,CAAC,CAAC,QAAQ,EAAE;CACd,CAAC,CAAC"}

package/dist/esm/flows-actors/agents-context.shared.schemas.d.ts

@@ -0,0 +1,181 @@
+import { z } from "zod";
+export declare enum RAG_ChunkingStrategy {
+    FIXED_SIZE = "fixed_size",
+    RECURSIVE = "recursive",
+    SEMANTIC = "semantic",
+    MARKDOWN = "markdown",
+    CODE = "code"
+}
+export declare enum RAG_RetrievalStrategy {
+    SEMANTIC = "semantic",
+    KEYWORD = "keyword",
+    HYBRID = "hybrid",
+    MMR = "mmr"
+}
+declare const _RAG_VectorStoreConfigurationSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        pinecone: "pinecone";
+        weaviate: "weaviate";
+        qdrant: "qdrant";
+        pgvector: "pgvector";
+        chromadb: "chromadb";
+        milvus: "milvus";
+    }>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    collection: z.ZodString;
+    dimension: z.ZodNumber;
+    metric: z.ZodEnum<{
+        cosine: "cosine";
+        euclidean: "euclidean";
+        dot_product: "dot_product";
+    }>;
+    indexConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_VectorStoreConfigurationSchema: typeof _RAG_VectorStoreConfigurationSchema;
+export type RAG_VectorStoreConfiguration = z.infer<typeof _RAG_VectorStoreConfigurationSchema>;
+declare const _RAG_EmbeddingConfigurationSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        custom: "custom";
+        openai: "openai";
+        cohere: "cohere";
+        huggingface: "huggingface";
+    }>;
+    model: z.ZodString;
+    dimension: z.ZodNumber;
+    batchSize: z.ZodOptional<z.ZodNumber>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_EmbeddingConfigurationSchema: typeof _RAG_EmbeddingConfigurationSchema;
+export type RAG_EmbeddingConfiguration = z.infer<typeof _RAG_EmbeddingConfigurationSchema>;
+declare const _RAG_ChunkingConfigurationSchema: z.ZodObject<{
+    strategy: z.ZodEnum<typeof RAG_ChunkingStrategy>;
+    chunkSize: z.ZodNumber;
+    chunkOverlap: z.ZodNumber;
+    separators: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    keepSeparator: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_ChunkingConfigurationSchema: typeof _RAG_ChunkingConfigurationSchema;
+export type RAG_ChunkingConfiguration = z.infer<typeof _RAG_ChunkingConfigurationSchema>;
+declare const _RAG_RetrievalConfigurationSchema: z.ZodObject<{
+    strategy: z.ZodEnum<typeof RAG_RetrievalStrategy>;
+    topK: z.ZodNumber;
+    scoreThreshold: z.ZodOptional<z.ZodNumber>;
+    filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    reranker: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        model: z.ZodOptional<z.ZodString>;
+        topN: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    hybridWeights: z.ZodOptional<z.ZodObject<{
+        semantic: z.ZodNumber;
+        keyword: z.ZodNumber;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_RetrievalConfigurationSchema: typeof _RAG_RetrievalConfigurationSchema;
+export type RAG_RetrievalConfiguration = z.infer<typeof _RAG_RetrievalConfigurationSchema>;
+declare const _RAG_ConfigurationSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    vectorStore: z.ZodObject<{
+        provider: z.ZodEnum<{
+            pinecone: "pinecone";
+            weaviate: "weaviate";
+            qdrant: "qdrant";
+            pgvector: "pgvector";
+            chromadb: "chromadb";
+            milvus: "milvus";
+        }>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        collection: z.ZodString;
+        dimension: z.ZodNumber;
+        metric: z.ZodEnum<{
+            cosine: "cosine";
+            euclidean: "euclidean";
+            dot_product: "dot_product";
+        }>;
+        indexConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip, core.$ZodObjectExtra>;
+    embedding: z.ZodObject<{
+        provider: z.ZodEnum<{
+            custom: "custom";
+            openai: "openai";
+            cohere: "cohere";
+            huggingface: "huggingface";
+        }>;
+        model: z.ZodString;
+        dimension: z.ZodNumber;
+        batchSize: z.ZodOptional<z.ZodNumber>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        endpoint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip, core.$ZodObjectExtra>;
+    chunking: z.ZodObject<{
+        strategy: z.ZodEnum<typeof RAG_ChunkingStrategy>;
+        chunkSize: z.ZodNumber;
+        chunkOverlap: z.ZodNumber;
+        separators: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        keepSeparator: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip, core.$ZodObjectExtra>;
+    retrieval: z.ZodObject<{
+        strategy: z.ZodEnum<typeof RAG_RetrievalStrategy>;
+        topK: z.ZodNumber;
+        scoreThreshold: z.ZodOptional<z.ZodNumber>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        reranker: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            model: z.ZodOptional<z.ZodString>;
+            topN: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+        hybridWeights: z.ZodOptional<z.ZodObject<{
+            semantic: z.ZodNumber;
+            keyword: z.ZodNumber;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip, core.$ZodObjectExtra>;
+    contextWindow: z.ZodOptional<z.ZodObject<{
+        maxTokens: z.ZodNumber;
+        reserveTokens: z.ZodNumber;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    caching: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        ttl: z.ZodNumber;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_ConfigurationSchema: typeof _RAG_ConfigurationSchema;
+export type RAG_Configuration = z.infer<typeof _RAG_ConfigurationSchema>;
+declare const _RAG_DocumentSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    chunks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>>;
+    source: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_DocumentSchema: typeof _RAG_DocumentSchema;
+export type RAG_Document = z.infer<typeof _RAG_DocumentSchema>;
+declare const _RAG_RetrievalResultSchema: z.ZodObject<{
+    query: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        chunkId: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        score: z.ZodNumber;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    retrievalStrategy: z.ZodEnum<typeof RAG_RetrievalStrategy>;
+    timestamp: z.ZodString;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const RAG_RetrievalResultSchema: typeof _RAG_RetrievalResultSchema;
+export type RAG_RetrievalResult = z.infer<typeof _RAG_RetrievalResultSchema>;
+export {};
+//# sourceMappingURL=agents-context.shared.schemas.d.ts.map

package/dist/esm/flows-actors/agents-context.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-context.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/flows-actors/agents-context.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,oBAAY,oBAAoB;IAC9B,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED,oBAAY,qBAAqB;IAC/B,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,GAAG,QAAQ;CACZ;AAED,QAAA,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;uCAQvC,CAAC;AAEH,eAAO,MAAM,kCAAkC,EAAE,OAAO,mCAAyE,CAAC;AAClI,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAE/F,QAAA,MAAM,iCAAiC;;;;;;;;;;;;uCAOrC,CAAC;AAEH,eAAO,MAAM,gCAAgC,EAAE,OAAO,iCAAqE,CAAC;AAC5H,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE3F,QAAA,MAAM,gCAAgC;;;;;;;uCAOpC,CAAC;AAEH,eAAO,MAAM,+BAA+B,EAAE,OAAO,gCAAmE,CAAC;AACzH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAEzF,QAAA,MAAM,iCAAiC;;;;;;;;;;;;;;uCAcrC,CAAC;AAEH,eAAO,MAAM,gCAAgC,EAAE,OAAO,iCAAqE,CAAC;AAC5H,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE3F,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAc5B,CAAC;AAEH,eAAO,MAAM,uBAAuB,EAAE,OAAO,wBAAmD,CAAC;AACjG,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEzE,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;uCAcvB,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,OAAO,mBAAyC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE/D,QAAA,MAAM,0BAA0B;;;;;;;;;;;;uCAY9B,CAAC;AAEH,eAAO,MAAM,yBAAyB,EAAE,OAAO,0BAAuD,CAAC;AACvG,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/esm/flows-actors/agents-context.shared.schemas.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+//===============================================================
+// RAG (Retrieval Augmented Generation)
+// TODO : refine this schema
+// --------
+// Configuration for retrieval augmented generation to enhance
+// agent responses with external knowledge. Supports vector stores,
+// embedding models, and various retrieval strategies including
+// semantic search, hybrid search, and reranking.
+//===============================================================
+export var RAG_ChunkingStrategy;
+(function (RAG_ChunkingStrategy) {
+    RAG_ChunkingStrategy["FIXED_SIZE"] = "fixed_size";
+    RAG_ChunkingStrategy["RECURSIVE"] = "recursive";
+    RAG_ChunkingStrategy["SEMANTIC"] = "semantic";
+    RAG_ChunkingStrategy["MARKDOWN"] = "markdown";
+    RAG_ChunkingStrategy["CODE"] = "code";
+})(RAG_ChunkingStrategy || (RAG_ChunkingStrategy = {}));
+export var RAG_RetrievalStrategy;
+(function (RAG_RetrievalStrategy) {
+    RAG_RetrievalStrategy["SEMANTIC"] = "semantic";
+    RAG_RetrievalStrategy["KEYWORD"] = "keyword";
+    RAG_RetrievalStrategy["HYBRID"] = "hybrid";
+    RAG_RetrievalStrategy["MMR"] = "mmr";
+})(RAG_RetrievalStrategy || (RAG_RetrievalStrategy = {}));
+const _RAG_VectorStoreConfigurationSchema = z.object({
+    provider: z.enum(["pinecone", "weaviate", "qdrant", "pgvector", "chromadb", "milvus"]),
+    endpoint: z.string().optional(),
+    apiKey: z.string().optional(),
+    collection: z.string(),
+    dimension: z.number(),
+    metric: z.enum(["cosine", "euclidean", "dot_product"]),
+    indexConfig: z.record(z.string(), z.unknown()).optional(),
+});
+export const RAG_VectorStoreConfigurationSchema = _RAG_VectorStoreConfigurationSchema;
+const _RAG_EmbeddingConfigurationSchema = z.object({
+    provider: z.enum(["openai", "cohere", "huggingface", "custom"]),
+    model: z.string(),
+    dimension: z.number(),
+    batchSize: z.number().optional(),
+    apiKey: z.string().optional(),
+    endpoint: z.string().optional(),
+});
+export const RAG_EmbeddingConfigurationSchema = _RAG_EmbeddingConfigurationSchema;
+const _RAG_ChunkingConfigurationSchema = z.object({
+    strategy: z.enum(RAG_ChunkingStrategy),
+    chunkSize: z.number(),
+    chunkOverlap: z.number(),
+    separators: z.array(z.string()).optional(),
+    keepSeparator: z.boolean().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+export const RAG_ChunkingConfigurationSchema = _RAG_ChunkingConfigurationSchema;
+const _RAG_RetrievalConfigurationSchema = z.object({
+    strategy: z.enum(RAG_RetrievalStrategy),
+    topK: z.number(),
+    scoreThreshold: z.number().optional(),
+    filter: z.record(z.string(), z.unknown()).optional(),
+    reranker: z.object({
+        enabled: z.boolean(),
+        model: z.string().optional(),
+        topN: z.number().optional(),
+    }).optional(),
+    hybridWeights: z.object({
+        semantic: z.number(),
+        keyword: z.number(),
+    }).optional(),
+});
+export const RAG_RetrievalConfigurationSchema = _RAG_RetrievalConfigurationSchema;
+const _RAG_ConfigurationSchema = z.object({
+    enabled: z.boolean(),
+    vectorStore: RAG_VectorStoreConfigurationSchema,
+    embedding: RAG_EmbeddingConfigurationSchema,
+    chunking: RAG_ChunkingConfigurationSchema,
+    retrieval: RAG_RetrievalConfigurationSchema,
+    contextWindow: z.object({
+        maxTokens: z.number(),
+        reserveTokens: z.number(), // tokens reserved for prompt/response
+    }).optional(),
+    caching: z.object({
+        enabled: z.boolean(),
+        ttl: z.number(),
+    }).optional(),
+});
+export const RAG_ConfigurationSchema = _RAG_ConfigurationSchema;
+const _RAG_DocumentSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    embedding: z.array(z.number()).optional(),
+    chunks: z.array(z.object({
+        id: z.string(),
+        content: z.string(),
+        embedding: z.array(z.number()).optional(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+    })).optional(),
+    source: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const RAG_DocumentSchema = _RAG_DocumentSchema;
+const _RAG_RetrievalResultSchema = z.object({
+    query: z.string(),
+    results: z.array(z.object({
+        documentId: z.string(),
+        chunkId: z.string().optional(),
+        content: z.string(),
+        score: z.number(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+    })),
+    retrievalStrategy: z.enum(RAG_RetrievalStrategy),
+    timestamp: z.string(),
+    duration: z.number().optional(),
+});
+export const RAG_RetrievalResultSchema = _RAG_RetrievalResultSchema;
+//# sourceMappingURL=agents-context.shared.schemas.js.map

package/dist/esm/flows-actors/agents-context.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-context.shared.schemas.js","sourceRoot":"","sources":["../../../src/flows-actors/agents-context.shared.schemas.ts"],"names":[],"mappings":"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"}

package/dist/esm/flows-actors/agents.shared.schemas.d.ts

@@ -0,0 +1,181 @@
+import { LLMProvider_OperationDefinitionBase, LLMProvider_OperationKey, LLMProvider_OperationModelConfiguration, LLMProvider_PromptFormat } from "@wildo-ai/external-connectors-models";
+import { FlowsActors_LeafElements_Configuration } from "./flows-actors.configuration.shared.schemas.js";
+import { FlowsActors_IO_PartKind } from "./flows-actors.io.shared.schemas.js";
+import { ExecutionContext_InitiatorIds } from "../runtime/execution-context.shared.schemas.js";
+import z from "zod";
+import { FlowsActors_Relationship } from "./flows-actors.commons.shared.schemas.js";
+import { AppsBlueprint_FileFormat } from "./apps-blueprint/artifacts.apps-blueprint.shared.schemas.js";
+/**
+ * Agent execution settings that stay stable across transport changes.
+ *
+ * `providerRef` and `model` still come from the semantic LLM configuration,
+ * while `executionProfileRef` selects one transport/runtime profile under the
+ * provider's `CLI_RUNTIME` protocol when execution should not use the default
+ * API-backed path.
+ */
+export type FlowsActors_Agent_ExecutionConfiguration = LLMProvider_OperationModelConfiguration & {
+    executionProfileRef?: string;
+};
+export type FlowsActors_Agent_Configuration = FlowsActors_LeafElements_Configuration & FlowsActors_Agent_ExecutionConfiguration & {
+    operationKey: LLMProvider_OperationKey;
+    seed?: number;
+};
+export declare enum FlowsActors_Agent_Status {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    DEPRECATED = "deprecated"
+}
+export declare enum FlowsActors_Agent_Skill_Type {
+    GENERATION = "generation",
+    ANALYSIS = "analysis",
+    TRANSFORMATION = "transformation",
+    DECISION = "decision",
+    CHAT = "chat",
+    CUSTOM = "custom"
+}
+export declare enum FlowsActors_Agent_Verbosity {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high"
+}
+export declare enum FlowsActors_Agent_Tone {
+    NEUTRAL = "neutral",
+    CASUAL = "casual",
+    FORMAL = "formal",
+    TECHNICAL = "technical"
+}
+export declare enum FlowsActors_Agent_ConstraintType {
+    SECURITY = "security",// Never reveal API keys, never execute arbitrary code
+    SAFETY = "safety",// Refuse harmful requests
+    PRIVACY = "privacy",// Handle PII appropriately
+    SCOPE = "scope",// Stay within task boundaries
+    COMPLIANCE = "compliance"
+}
+export declare const FlowsActors_Agent_ConstraintSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    type: z.ZodEnum<typeof FlowsActors_Agent_ConstraintType>;
+    onViolation: z.ZodDefault<z.ZodEnum<{
+        refuse: "refuse";
+        warn: "warn";
+        log: "log";
+    }>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type FlowsActors_Agent_Constraint = z.infer<typeof FlowsActors_Agent_ConstraintSchema>;
+export declare const FlowsActors_Agent_OutputSpecSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<typeof FlowsActors_IO_PartKind>>;
+    fileFormat: z.ZodOptional<z.ZodEnum<typeof AppsBlueprint_FileFormat>>;
+    lengthGuidance: z.ZodOptional<z.ZodEnum<typeof FlowsActors_Agent_Verbosity>>;
+    includeReasoning: z.ZodOptional<z.ZodBoolean>;
+    requiredSections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type FlowsActors_Agent_OutputSpec = z.infer<typeof FlowsActors_Agent_OutputSpecSchema>;
+export declare enum FlowsActors_Agent_UncertaintyPolicy {
+    ASK = "ask",// Ask for clarification
+    INFER = "infer",// Make reasonable inferences
+    CONSERVATIVE = "conservative",// Choose safest option
+    FAIL = "fail"
+}
+export declare const FlowsActors_Agent_UncertaintySchema: z.ZodObject<{
+    policy: z.ZodDefault<z.ZodEnum<typeof FlowsActors_Agent_UncertaintyPolicy>>;
+    confidenceThreshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type FlowsActors_Agent_Uncertainty = z.infer<typeof FlowsActors_Agent_UncertaintySchema>;
+export declare const FlowsActors_Agent_PromptSpecSchema: z.ZodObject<{
+    role: z.ZodString;
+    persona: z.ZodOptional<z.ZodString>;
+    skillType: z.ZodEnum<typeof FlowsActors_Agent_Skill_Type>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        type: z.ZodEnum<typeof FlowsActors_Agent_ConstraintType>;
+        onViolation: z.ZodDefault<z.ZodEnum<{
+            refuse: "refuse";
+            warn: "warn";
+            log: "log";
+        }>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>>;
+    goal: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<typeof FlowsActors_IO_PartKind>>;
+        fileFormat: z.ZodOptional<z.ZodEnum<typeof AppsBlueprint_FileFormat>>;
+        lengthGuidance: z.ZodOptional<z.ZodEnum<typeof FlowsActors_Agent_Verbosity>>;
+        includeReasoning: z.ZodOptional<z.ZodBoolean>;
+        requiredSections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    instructions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    uncertainty: z.ZodOptional<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<typeof FlowsActors_Agent_UncertaintyPolicy>>;
+        confidenceThreshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    outOfScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        input: z.ZodString;
+        output: z.ZodString;
+        explanation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip, core.$ZodObjectExtra>>>;
+    style: z.ZodOptional<z.ZodObject<{
+        verbosity: z.ZodOptional<z.ZodEnum<typeof FlowsActors_Agent_Verbosity>>;
+        tone: z.ZodOptional<z.ZodEnum<typeof FlowsActors_Agent_Tone>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    curation: z.ZodOptional<z.ZodObject<{
+        maxItems: z.ZodOptional<z.ZodNumber>;
+        minRelevance: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    promptFormatOverride: z.ZodOptional<z.ZodEnum<typeof LLMProvider_PromptFormat>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        lastModified: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        changelog: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type FlowsActors_Agent_PromptSpec = z.infer<typeof FlowsActors_Agent_PromptSpecSchema>;
+export type FlowsActors_Agent = {
+    /** Unique agent reference for flow/actor calls */
+    ref: string;
+    /** Human-readable display name */
+    displayName: string;
+    /** Agent lifecycle status */
+    status: FlowsActors_Agent_Status;
+    /** LLM provider and model configuration */
+    config: FlowsActors_Agent_Configuration;
+    /** Operation definition (input/output types, etc.) */
+    operationDefinition: LLMProvider_OperationDefinitionBase;
+    /**
+     * Complete prompt specification
+     * Defines role, persona, constraints, instructions, output format, etc.
+     */
+    promptSpec: FlowsActors_Agent_PromptSpec;
+    /** Agent capabilities (tools, etc.) */
+    capabilities?: {
+        tools?: {
+            /** References to callable functions */
+            functionRefs: string[];
+            /** References to MCP servers */
+            mcpRefs: string[];
+        };
+    };
+    /** Agent definition version */
+    version?: string;
+    /** Creation timestamp (ISO 8601) */
+    createdAt: string;
+    /** Last update timestamp (ISO 8601) */
+    updatedAt?: string;
+};
+export type FlowsActors_Agent_Invocation<InputSchema extends z.ZodSchema<any> = z.ZodSchema<any>, OutputSchema extends z.ZodSchema<any> = z.ZodSchema<any>, ContextSchema extends z.ZodSchema<any> = z.ZodSchema<any>> = {
+    _id?: string;
+    agentRef: string;
+    initiator: ExecutionContext_InitiatorIds;
+    invocationContext: FlowsActors_Relationship[];
+    input: z.infer<InputSchema>;
+    output: z.infer<OutputSchema>;
+    executionContext: z.infer<ContextSchema>;
+    artifactBindings: {
+        kind: FlowsActors_IO_PartKind;
+        ref: string;
+    }[];
+};
+//# sourceMappingURL=agents.shared.schemas.d.ts.map

package/dist/esm/flows-actors/agents.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/flows-actors/agents.shared.schemas.ts"],"names":[],"mappings":"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"}