diff --git a/.github/_typos.toml b/.github/_typos.toml index 0f48033521ce..88a4e7e9b8d3 100644 --- a/.github/_typos.toml +++ b/.github/_typos.toml @@ -27,6 +27,7 @@ extend-exclude = [ "**/azure_ai_search_hotel_samples/README.md", "**/Demos/ProcessFrameworkWithAspire/ProcessFramework.Aspire/ProcessFramework.Aspire.ProcessOrchestrator/Program.cs", "**/Demos/ProcessFrameworkWithAspire/**/*.http", + "**/samples/GettingStartedWithProcesses/**/States/**/*.json", "**/samples/Concepts/Resources/travel-destination-overview.txt" ] diff --git a/dotnet/SK-dotnet.slnx b/dotnet/SK-dotnet.slnx index 495a570d6941..21a10654d82b 100644 --- a/dotnet/SK-dotnet.slnx +++ b/dotnet/SK-dotnet.slnx @@ -79,7 +79,7 @@ - + diff --git a/dotnet/samples/Demos/ProcessFrameworkWithAspire/ProcessFramework.Aspire/ProcessFramework.Aspire.ProcessOrchestrator/Program.cs b/dotnet/samples/Demos/ProcessFrameworkWithAspire/ProcessFramework.Aspire/ProcessFramework.Aspire.ProcessOrchestrator/Program.cs index d200c9f05cb1..62743479c396 100644 --- a/dotnet/samples/Demos/ProcessFrameworkWithAspire/ProcessFramework.Aspire/ProcessFramework.Aspire.ProcessOrchestrator/Program.cs +++ b/dotnet/samples/Demos/ProcessFrameworkWithAspire/ProcessFramework.Aspire/ProcessFramework.Aspire.ProcessOrchestrator/Program.cs @@ -34,11 +34,11 @@ processBuilder .OnInputEvent(ProcessEvents.TranslateDocument) - .SendEventTo(new(translateDocumentStep, TranslateStep.ProcessFunctions.Translate, parameterName: "textToTranslate")); + .SendEventTo(new(translateDocumentStep, TranslateStep.ProcessFunctions.Translate)); translateDocumentStep .OnEvent(ProcessEvents.DocumentTranslated) - .SendEventTo(new ProcessFunctionTargetBuilder(summarizeDocumentStep, SummarizeStep.ProcessFunctions.Summarize, parameterName: "textToSummarize")); + .SendEventTo(new ProcessFunctionTargetBuilder(summarizeDocumentStep, SummarizeStep.ProcessFunctions.Summarize)); summarizeDocumentStep .OnEvent(ProcessEvents.DocumentSummarized) diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/.vscode/tasks.json b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/.vscode/tasks.json index 2daee70e790c..7fc65f97a796 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/.vscode/tasks.json +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/.vscode/tasks.json @@ -20,8 +20,24 @@ "type": "npm", "script": "protoc --ts_out .\\src\\services\\grpc\\gen --ts_opt generate_dependencies --proto_path .\\src\\services\\grpc\\proto .\\src\\services\\grpc\\proto\\documentGeneration.proto", "problemMatcher": [], - "label": "protobuf: generate document generation proto files", + "label": "protobuf: generate 'document generation' proto files", "detail": "Generate necessary proto files for document generation" + }, + { + "type": "npm", + "script": "protoc --ts_out .\\src\\services\\grpc\\gen --ts_opt generate_dependencies --proto_path .\\src\\services\\grpc\\proto .\\src\\services\\grpc\\proto\\teacherStudentInteraction.proto", + "problemMatcher": [], + "label": "protobuf: generate 'teacher student interaction' proto files", + "detail": "Generate necessary proto files for teacher student interaction" + }, + { + "label": "protobuf: generate all proto files", + "type": "shell", + "dependsOn": [ + "protobuf: generate 'document generation' proto files", + "protobuf: generate 'teacher student interaction' proto files" + ], + "problemMatcher": [] } ] } \ No newline at end of file diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/App.tsx b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/App.tsx index 29e8ed528163..0775c0947993 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/App.tsx +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/App.tsx @@ -28,6 +28,12 @@ import GenerateDocsChat, { NewDocument, } from "./components/GenerateDocumentsChat"; import { ExitIcon } from "./components/Icons"; +import TeacherStudentInteractionChat, { + StudentTeacherEntry, + TeacherStudentInteractionUser, +} from "./components/TeacherStudentInteractionChat"; +import { grpcTeacherStudentService } from "./services/grpc/grpcClients"; +import { User } from "./services/grpc/gen/teacherStudentInteraction"; interface AppProps { grpcDocClient?: GrpcDocumentationGenerationClient; @@ -77,12 +83,16 @@ const App: React.FC = ({ grpcDocClient }) => { const [selectedAppPage, setSelectedAppPage] = useState( AppPages.DocumentGeneration ); + // generated documents related const [generatedDocuments, setGeneratedDocuments] = useState( [] ); const [publishedDocuments, setPublishedDocuments] = useState( [] ); + // teacher student interaction related + const [studentAgentInteractionMessages, setStudentAgentInteractionMessages] = + useState([]); const [hasGrpcError, setHasGrpcError] = useState(false); @@ -196,7 +206,9 @@ const App: React.FC = ({ grpcDocClient }) => { } }; - const subscribeToSpecificProcessId = async (processId: string) => { + const subscribeToSpecificProcessIdForDocumentGeneration = async ( + processId: string + ) => { subscribeReceiveDocumentForReview(processId); subscribeToReceivePublishedDocument(processId); return Promise.all([ @@ -207,6 +219,109 @@ const App: React.FC = ({ grpcDocClient }) => { }); }; + // teacher student interaction related + + const onUserStartedTeacherInteractionProcess = ( + processId: string + ): Promise => { + if (selectedCloudTech == CloudTechnology.GRPC) { + if (grpcTeacherStudentService) { + return grpcTeacherStudentService + .startProcess({ + processId: processId, + }) + .then(() => { + console.log( + "[GRPC] User student interaction process started" + ); + setHasGrpcError(false); + return true; + }) + .catch((error) => { + console.error( + "[GRPC] Error starting student interaction process", + error + ); + setHasGrpcError(true); + return false; + }); + } + } + return new Promise((resolve) => resolve(false)); + }; + + const onSendTeacherQuestion = ( + teacherInteraction: StudentTeacherEntry + ): Promise => { + if (selectedCloudTech == CloudTechnology.GRPC) { + if (grpcTeacherStudentService) { + return grpcTeacherStudentService + .requestStudentAgentResponse({ + processId: teacherInteraction.processId, + content: teacherInteraction.content!, + user: User.TEACHER, + }) + .then(() => { + console.log( + "[GRPC] User teacher question sent to student agent" + ); + setHasGrpcError(false); + return true; + }) + .catch((error) => { + console.error( + "[GRPC] Error sending teacher question to student agent", + error + ); + setHasGrpcError(true); + return false; + }); + } + } + return new Promise((resolve) => resolve(false)); + }; + + const subscribeToStudentAgentResponses = async (processId: string) => { + if (selectedCloudTech == CloudTechnology.GRPC) { + if (grpcTeacherStudentService) { + // grpc stream for receiving published document + const studentResponseStream = + grpcTeacherStudentService.receiveStudentAgentResponse({ + processId: processId, + }); + for await (const message of studentResponseStream.responses) { + setStudentAgentInteractionMessages((prevMessages) => [ + ...prevMessages, + { + processId: message.processId, + content: message.content, + user: TeacherStudentInteractionUser.STUDENT, + }, + ]); + console.log( + "[GRPC] Student interaction received: ", + message + ); + } + } + } + }; + + const subscribeToSpecificProcessIdForTeacherStudentInteraction = async ( + processId: string + ) => { + subscribeReceiveDocumentForReview(processId); + subscribeToReceivePublishedDocument(processId); + return Promise.all([subscribeToStudentAgentResponses(processId)]).then( + () => { + return; + } + ); + }; + + const getCloudTechnologyName = () => + CloudTechnologiesDetails.get(selectedCloudTech)!.name; + return (
@@ -285,19 +400,31 @@ const App: React.FC = ({ grpcDocClient }) => { )} {selectedAppPage == AppPages.DocumentGeneration && ( )} + {selectedAppPage == AppPages.TeacherStudentInteraction && ( + + )}
); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/common/AppConstants.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/common/AppConstants.ts index 24c620056c93..52cd0bc9f801 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/common/AppConstants.ts +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/common/AppConstants.ts @@ -7,6 +7,7 @@ // Additionally update the AppPagesDetails map to include the new process sample and its details. export enum AppPages { DocumentGeneration = "DocumentGeneration", + TeacherStudentInteraction = "TeacherStudentInteraction", } interface EnumDetails { @@ -23,6 +24,14 @@ export const AppPagesDetails = new Map([ "Demo used to show case document generation using different cloud technologies with SK Processes", }, ], + [ + AppPages.TeacherStudentInteraction, + { + name: "Teacher Student Interaction", + description: + "Demo used to show case teacher student interaction using different cloud technologies and declarative agents with SK Processes", + } + ] ]); // When more cloud technologies are added, add them to this enum and the CloudTechnologiesDetails map below. diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/ChatHeader.tsx b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/ChatHeader.tsx new file mode 100644 index 000000000000..eddab6d6a2cf --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/ChatHeader.tsx @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2025 Microsoft + * All rights reserved. + */ + +import React from "react"; +import { Title2, Label, makeStyles } from "@fluentui/react-components"; // Adjust imports based on your UI library + +interface ChatHeaderProps { + header: string; + processId?: string; +} + +const useStyles = makeStyles({ + processIdContainer: { + display: "flex", + flexDirection: "column", + rowGap: "8px", + alignItems: "flex-end", + }, + headerContainer: { + display: "flex", + justifyContent: "space-between", + }, +}); + +const ChatHeader: React.FC = ({ + header, + processId, +}) => { + const styles = useStyles(); + + return ( +
+ + {header} + +
+ + +
+
+ ); +}; + +export default ChatHeader; diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/GenerateDocumentsChat.tsx b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/GenerateDocumentsChat.tsx index 4bd8ea3726a7..27b14e093b7a 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/GenerateDocumentsChat.tsx +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/GenerateDocumentsChat.tsx @@ -22,6 +22,7 @@ import Markdown from "react-markdown"; import { ChatMessageContent, ChatUser } from "../common/ChatConstants"; import SimpleChat from "./SimpleChat"; import { CheckIcon, RejectIcon } from "./Icons"; +import ChatHeader from "./ChatHeader"; export interface NewDocument { title?: string; @@ -51,12 +52,6 @@ const useStyles = makeStyles({ rowGap: "8px", width: "90%", }, - processIdContainer: { - display: "flex", - flexDirection: "column", - rowGap: "8px", - alignItems: "flex-end", - }, buttonsFamily: { display: "flex", columnGap: "40px", @@ -69,10 +64,6 @@ const useStyles = makeStyles({ newDocHeaderHeader: { marginTop: "0", }, - headerContainer: { - display: "flex", - justifyContent: "space-between", - }, }); const GenerateDocsChat: React.FC = ({ @@ -264,13 +255,7 @@ const GenerateDocsChat: React.FC = ({ return (
-
- Document Generation with {cloudTechnologyName} -
- - -
-
+
diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/TeacherStudentInteractionChat.tsx b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/TeacherStudentInteractionChat.tsx new file mode 100644 index 000000000000..37ca69ae5a42 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/components/TeacherStudentInteractionChat.tsx @@ -0,0 +1,251 @@ +/* + * Copyright (c) 2025 Microsoft + * All rights reserved. + */ +import { useEffect, useState } from "react"; +import { v4 as uuidv4 } from "uuid"; +import { + Button, + Dropdown, + makeStyles, + Option, + Spinner, +} from "@fluentui/react-components"; +import { ChatMessageContent, ChatUser } from "../common/ChatConstants"; +import SimpleChat from "./SimpleChat"; +import ChatHeader from "./ChatHeader"; + +export enum TeacherStudentInteractionUser { + TEACHER = "TEACHER", + STUDENT = "STUDENT", +} + +export interface StudentTeacherEntry { + processId: string; + content?: string; + user: TeacherStudentInteractionUser; +} + +interface TeacherStudentInteractionChatProps { + cloudTechnologyName: string; + newStudentAgentResponses: StudentTeacherEntry[]; + onStartNewProcess?: (processId: string) => Promise; + onSendTeacherQuestion?: ( + teacherInteraction: StudentTeacherEntry + ) => Promise; + subscribeToSpecificProcessId?: (processId: string) => Promise; +} + +const useStyles = makeStyles({ + root: { + display: "flex", + flexDirection: "column", + rowGap: "8px", + width: "90%", + }, + processIdContainer: { + display: "flex", + flexDirection: "column", + rowGap: "8px", + alignItems: "flex-end", + }, + buttonsFamily: { + display: "flex", + columnGap: "40px", + }, + headerContainer: { + display: "flex", + justifyContent: "space-between", + }, +}); + +const teacherMathQuestions = [ + "What is 2 + 2?", + "Can you explain the Pythagorean theorem?", + "What is the integral of sin(x)?", + "What is the area of a circle?", +]; + +const TeacherStudentInteractionChat: React.FC< + TeacherStudentInteractionChatProps +> = ({ + cloudTechnologyName, + newStudentAgentResponses, + onStartNewProcess, + onSendTeacherQuestion, + subscribeToSpecificProcessId +}) => { + const styles = useStyles(); + + const [messages, setMessages] = useState([]); + const [processId, setProcessId] = useState(); + const [startingNewProcess, setStartingNewProcess] = + useState(false); + const [selectedTeacherQuestion, setSelectedTeacherQuestion] = + useState(); + + useEffect(() => { + if (processId) { + subscribeToSpecificProcessId?.(processId); + } + }, [processId]); + + useEffect(() => { + if (processId) { + // subscribeToSpecificProcessId(processId); + } + }, [processId]); + + const formatStudentResponseString = (response: string) => { + return `Student Agent: ${response}`; + }; + + useEffect(() => { + if (newStudentAgentResponses.length > 0) { + const lastResponse = + newStudentAgentResponses[newStudentAgentResponses.length - 1]; + if (lastResponse.processId !== processId) { + console.warn( + `Received response for a different processId - ignoring ${lastResponse}` + ); + return; + } + + setMessages((prevMessages) => [ + ...prevMessages, + { + sender: ChatUser.ASSISTANT, + content: formatStudentResponseString( + lastResponse.content ?? "" + ), + timestamp: new Date().toLocaleString(), + }, + ]); + } + }, [newStudentAgentResponses]); + + const OnStartNewProcessClicked = () => { + // Need to know processId to be able to subscribe to incoming events from this process once it is running + // processId is used as identifier to start/resume process + const newProcessId = uuidv4(); + setProcessId(newProcessId); + + onStartNewProcess?.(newProcessId) + .then((result) => { + if (result) { + setMessages((prevMessages) => [...prevMessages]); + } + }) + .finally(() => { + setStartingNewProcess(false); + }); + + setMessages((prevMessages) => [ + ...prevMessages, + { + sender: ChatUser.USER, + action: `New process started - ${newProcessId}`, + timestamp: new Date().toLocaleString(), + }, + ]); + setStartingNewProcess(true); + }; + + const onSendTeacherQuestionClicked = () => { + if (!processId) { + alert("Process ID is not set. Please start a new process first."); + return; + } + if (!selectedTeacherQuestion) { + alert("Please select a teacher question first."); + return; + } + + onSendTeacherQuestion?.({ + processId, + user: TeacherStudentInteractionUser.TEACHER, + content: selectedTeacherQuestion, + }) + .then((result) => { + if (result) { + console.log("Successfully sent teacher question"); + } + }) + .catch((error) => { + console.error("Error sending teacher question:", error); + setMessages((prevMessages) => [ + ...prevMessages, + { + sender: ChatUser.ASSISTANT, + content: `Something went wrong and could not send question - ${error}`, + timestamp: new Date().toLocaleString(), + }, + ]); + }); + + setMessages((prevMessages) => [ + ...prevMessages, + { + sender: ChatUser.USER, + content: `User asked teacher question - ${selectedTeacherQuestion}`, + timestamp: new Date().toLocaleString(), + }, + ]); + }; + + const onClearChat = () => { + setMessages([]); + setProcessId(""); + }; + + return ( +
+ + +
+ + {/* {processId && ( */} + + setSelectedTeacherQuestion(data.optionValue) + } + > + {teacherMathQuestions.map((question) => ( + + ))} + + + +
+
+ ); +}; + +export default TeacherStudentInteractionChat; diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/main.tsx b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/main.tsx index b4b78c76abf2..4a73e004825e 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/main.tsx +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/main.tsx @@ -3,7 +3,7 @@ * All rights reserved. */ import { createRoot } from "react-dom/client"; -import { grpcDocService } from "./services/grpc/DocumentGenerationGrpcClient.ts"; +import { grpcDocService } from "./services/grpc/grpcClients.ts"; import { FluentProvider, webLightTheme } from "@fluentui/react-components"; import "./index.css"; import App from "./App.tsx"; diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/DocumentGenerationGrpcClient.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/DocumentGenerationGrpcClient.ts deleted file mode 100644 index 3ad067e2ef9f..000000000000 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/DocumentGenerationGrpcClient.ts +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2025 Microsoft - * All rights reserved. - */ -import { GrpcWebFetchTransport } from "@protobuf-ts/grpcweb-transport"; -import { GrpcDocumentationGenerationClient } from "./gen/documentGeneration.client"; - -const createGrpcDocGenerationClient = () => { - try { - const transport = new GrpcWebFetchTransport({ - baseUrl: "http://localhost:58640", - format: "text", - }); - return new GrpcDocumentationGenerationClient(transport); - } catch (error) { - console.error("Could not create connection with gRPC server", error); - return undefined; - } -}; - -export const grpcDocService = createGrpcDocGenerationClient(); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.client.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.client.ts index accafe6f7a52..4831262d1262 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.client.ts +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.client.ts @@ -1,5 +1,5 @@ // @generated by protobuf-ts 2.9.6 with parameter generate_dependencies -// @generated from protobuf file "documentGeneration.proto" (syntax proto3) +// @generated from protobuf file "documentGeneration.proto" (package "ProcessWithCloudEvents.Grpc.Contract", syntax proto3) // tslint:disable import type { RpcTransport } from "@protobuf-ts/runtime-rpc"; import type { ServiceInfo } from "@protobuf-ts/runtime-rpc"; @@ -14,36 +14,36 @@ import type { FeatureDocumentationRequest } from "./documentGeneration"; import type { UnaryCall } from "@protobuf-ts/runtime-rpc"; import type { RpcOptions } from "@protobuf-ts/runtime-rpc"; /** - * @generated from protobuf service GrpcDocumentationGeneration + * @generated from protobuf service ProcessWithCloudEvents.Grpc.Contract.GrpcDocumentationGeneration */ export interface IGrpcDocumentationGenerationClient { /** - * @generated from protobuf rpc: UserRequestFeatureDocumentation(FeatureDocumentationRequest) returns (ProcessData); + * @generated from protobuf rpc: UserRequestFeatureDocumentation(ProcessWithCloudEvents.Grpc.Contract.FeatureDocumentationRequest) returns (ProcessWithCloudEvents.Grpc.Contract.ProcessData); */ userRequestFeatureDocumentation(input: FeatureDocumentationRequest, options?: RpcOptions): UnaryCall; /** - * @generated from protobuf rpc: RequestUserReviewDocumentationFromProcess(DocumentationContentRequest) returns (Empty); + * @generated from protobuf rpc: RequestUserReviewDocumentationFromProcess(ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest) returns (ProcessWithCloudEvents.Grpc.Contract.Empty); */ requestUserReviewDocumentationFromProcess(input: DocumentationContentRequest, options?: RpcOptions): UnaryCall; /** - * @generated from protobuf rpc: RequestUserReviewDocumentation(ProcessData) returns (stream DocumentationContentRequest); + * @generated from protobuf rpc: RequestUserReviewDocumentation(ProcessWithCloudEvents.Grpc.Contract.ProcessData) returns (stream ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest); */ requestUserReviewDocumentation(input: ProcessData, options?: RpcOptions): ServerStreamingCall; /** - * @generated from protobuf rpc: UserReviewedDocumentation(DocumentationApprovalRequest) returns (Empty); + * @generated from protobuf rpc: UserReviewedDocumentation(ProcessWithCloudEvents.Grpc.Contract.DocumentationApprovalRequest) returns (ProcessWithCloudEvents.Grpc.Contract.Empty); */ userReviewedDocumentation(input: DocumentationApprovalRequest, options?: RpcOptions): UnaryCall; /** - * @generated from protobuf rpc: PublishDocumentation(DocumentationContentRequest) returns (Empty); + * @generated from protobuf rpc: PublishDocumentation(ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest) returns (ProcessWithCloudEvents.Grpc.Contract.Empty); */ publishDocumentation(input: DocumentationContentRequest, options?: RpcOptions): UnaryCall; /** - * @generated from protobuf rpc: ReceivePublishedDocumentation(ProcessData) returns (stream DocumentationContentRequest); + * @generated from protobuf rpc: ReceivePublishedDocumentation(ProcessWithCloudEvents.Grpc.Contract.ProcessData) returns (stream ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest); */ receivePublishedDocumentation(input: ProcessData, options?: RpcOptions): ServerStreamingCall; } /** - * @generated from protobuf service GrpcDocumentationGeneration + * @generated from protobuf service ProcessWithCloudEvents.Grpc.Contract.GrpcDocumentationGeneration */ export class GrpcDocumentationGenerationClient implements IGrpcDocumentationGenerationClient, ServiceInfo { typeName = GrpcDocumentationGeneration.typeName; @@ -52,42 +52,42 @@ export class GrpcDocumentationGenerationClient implements IGrpcDocumentationGene constructor(private readonly _transport: RpcTransport) { } /** - * @generated from protobuf rpc: UserRequestFeatureDocumentation(FeatureDocumentationRequest) returns (ProcessData); + * @generated from protobuf rpc: UserRequestFeatureDocumentation(ProcessWithCloudEvents.Grpc.Contract.FeatureDocumentationRequest) returns (ProcessWithCloudEvents.Grpc.Contract.ProcessData); */ userRequestFeatureDocumentation(input: FeatureDocumentationRequest, options?: RpcOptions): UnaryCall { const method = this.methods[0], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** - * @generated from protobuf rpc: RequestUserReviewDocumentationFromProcess(DocumentationContentRequest) returns (Empty); + * @generated from protobuf rpc: RequestUserReviewDocumentationFromProcess(ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest) returns (ProcessWithCloudEvents.Grpc.Contract.Empty); */ requestUserReviewDocumentationFromProcess(input: DocumentationContentRequest, options?: RpcOptions): UnaryCall { const method = this.methods[1], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** - * @generated from protobuf rpc: RequestUserReviewDocumentation(ProcessData) returns (stream DocumentationContentRequest); + * @generated from protobuf rpc: RequestUserReviewDocumentation(ProcessWithCloudEvents.Grpc.Contract.ProcessData) returns (stream ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest); */ requestUserReviewDocumentation(input: ProcessData, options?: RpcOptions): ServerStreamingCall { const method = this.methods[2], opt = this._transport.mergeOptions(options); return stackIntercept("serverStreaming", this._transport, method, opt, input); } /** - * @generated from protobuf rpc: UserReviewedDocumentation(DocumentationApprovalRequest) returns (Empty); + * @generated from protobuf rpc: UserReviewedDocumentation(ProcessWithCloudEvents.Grpc.Contract.DocumentationApprovalRequest) returns (ProcessWithCloudEvents.Grpc.Contract.Empty); */ userReviewedDocumentation(input: DocumentationApprovalRequest, options?: RpcOptions): UnaryCall { const method = this.methods[3], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** - * @generated from protobuf rpc: PublishDocumentation(DocumentationContentRequest) returns (Empty); + * @generated from protobuf rpc: PublishDocumentation(ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest) returns (ProcessWithCloudEvents.Grpc.Contract.Empty); */ publishDocumentation(input: DocumentationContentRequest, options?: RpcOptions): UnaryCall { const method = this.methods[4], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** - * @generated from protobuf rpc: ReceivePublishedDocumentation(ProcessData) returns (stream DocumentationContentRequest); + * @generated from protobuf rpc: ReceivePublishedDocumentation(ProcessWithCloudEvents.Grpc.Contract.ProcessData) returns (stream ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest); */ receivePublishedDocumentation(input: ProcessData, options?: RpcOptions): ServerStreamingCall { const method = this.methods[5], opt = this._transport.mergeOptions(options); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.ts index 754f9cfa6487..3ecdd396dea5 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.ts +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/documentGeneration.ts @@ -1,5 +1,5 @@ // @generated by protobuf-ts 2.9.6 with parameter generate_dependencies -// @generated from protobuf file "documentGeneration.proto" (syntax proto3) +// @generated from protobuf file "documentGeneration.proto" (package "ProcessWithCloudEvents.Grpc.Contract", syntax proto3) // tslint:disable import { ServiceType } from "@protobuf-ts/runtime-rpc"; import type { BinaryWriteOptions } from "@protobuf-ts/runtime"; @@ -12,7 +12,7 @@ import type { PartialMessage } from "@protobuf-ts/runtime"; import { reflectionMergePartial } from "@protobuf-ts/runtime"; import { MessageType } from "@protobuf-ts/runtime"; /** - * @generated from protobuf message FeatureDocumentationRequest + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.FeatureDocumentationRequest */ export interface FeatureDocumentationRequest { /** @@ -33,7 +33,7 @@ export interface FeatureDocumentationRequest { processId: string; } /** - * @generated from protobuf message DocumentationContentRequest + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest */ export interface DocumentationContentRequest { /** @@ -49,12 +49,12 @@ export interface DocumentationContentRequest { */ assistantMessage: string; /** - * @generated from protobuf field: ProcessData processData = 10; + * @generated from protobuf field: ProcessWithCloudEvents.Grpc.Contract.ProcessData processData = 10; */ processData?: ProcessData; } /** - * @generated from protobuf message DocumentationApprovalRequest + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.DocumentationApprovalRequest */ export interface DocumentationApprovalRequest { /** @@ -66,12 +66,12 @@ export interface DocumentationApprovalRequest { */ reason: string; /** - * @generated from protobuf field: ProcessData processData = 10; + * @generated from protobuf field: ProcessWithCloudEvents.Grpc.Contract.ProcessData processData = 10; */ processData?: ProcessData; } /** - * @generated from protobuf message ProcessData + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.ProcessData */ export interface ProcessData { /** @@ -80,14 +80,14 @@ export interface ProcessData { processId: string; } /** - * @generated from protobuf message Empty + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.Empty */ export interface Empty { } // @generated message type with reflection information, may provide speed optimized methods class FeatureDocumentationRequest$Type extends MessageType { constructor() { - super("FeatureDocumentationRequest", [ + super("ProcessWithCloudEvents.Grpc.Contract.FeatureDocumentationRequest", [ { no: 1, name: "title", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, { no: 2, name: "userDescription", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, { no: 3, name: "content", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, @@ -152,13 +152,13 @@ class FeatureDocumentationRequest$Type extends MessageType { constructor() { - super("DocumentationContentRequest", [ + super("ProcessWithCloudEvents.Grpc.Contract.DocumentationContentRequest", [ { no: 1, name: "title", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, { no: 2, name: "content", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, { no: 3, name: "assistantMessage", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, @@ -188,7 +188,7 @@ class DocumentationContentRequest$Type extends MessageType { constructor() { - super("DocumentationApprovalRequest", [ + super("ProcessWithCloudEvents.Grpc.Contract.DocumentationApprovalRequest", [ { no: 1, name: "documentationApproved", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, { no: 10, name: "processData", kind: "message", T: () => ProcessData } @@ -253,7 +253,7 @@ class DocumentationApprovalRequest$Type extends MessageType { constructor() { - super("ProcessData", [ + super("ProcessWithCloudEvents.Grpc.Contract.ProcessData", [ { no: 1, name: "processId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } ]); } @@ -331,13 +331,13 @@ class ProcessData$Type extends MessageType { } } /** - * @generated MessageType for protobuf message ProcessData + * @generated MessageType for protobuf message ProcessWithCloudEvents.Grpc.Contract.ProcessData */ export const ProcessData = new ProcessData$Type(); // @generated message type with reflection information, may provide speed optimized methods class Empty$Type extends MessageType { constructor() { - super("Empty", []); + super("ProcessWithCloudEvents.Grpc.Contract.Empty", []); } create(value?: PartialMessage): Empty { const message = globalThis.Object.create((this.messagePrototype!)); @@ -369,13 +369,13 @@ class Empty$Type extends MessageType { } } /** - * @generated MessageType for protobuf message Empty + * @generated MessageType for protobuf message ProcessWithCloudEvents.Grpc.Contract.Empty */ export const Empty = new Empty$Type(); /** - * @generated ServiceType for protobuf service GrpcDocumentationGeneration + * @generated ServiceType for protobuf service ProcessWithCloudEvents.Grpc.Contract.GrpcDocumentationGeneration */ -export const GrpcDocumentationGeneration = new ServiceType("GrpcDocumentationGeneration", [ +export const GrpcDocumentationGeneration = new ServiceType("ProcessWithCloudEvents.Grpc.Contract.GrpcDocumentationGeneration", [ { name: "UserRequestFeatureDocumentation", options: {}, I: FeatureDocumentationRequest, O: ProcessData }, { name: "RequestUserReviewDocumentationFromProcess", options: {}, I: DocumentationContentRequest, O: Empty }, { name: "RequestUserReviewDocumentation", serverStreaming: true, options: {}, I: ProcessData, O: DocumentationContentRequest }, diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/teacherStudentInteraction.client.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/teacherStudentInteraction.client.ts new file mode 100644 index 000000000000..727c3bff03bd --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/teacherStudentInteraction.client.ts @@ -0,0 +1,71 @@ +// @generated by protobuf-ts 2.9.6 with parameter generate_dependencies +// @generated from protobuf file "teacherStudentInteraction.proto" (package "ProcessWithCloudEvents.Grpc.Contract", syntax proto3) +// tslint:disable +import type { RpcTransport } from "@protobuf-ts/runtime-rpc"; +import type { ServiceInfo } from "@protobuf-ts/runtime-rpc"; +import { GrpcTeacherStudentInteraction } from "./teacherStudentInteraction"; +import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc"; +import type { MessageContent } from "./teacherStudentInteraction"; +import { stackIntercept } from "@protobuf-ts/runtime-rpc"; +import type { ProcessDetails } from "./teacherStudentInteraction"; +import type { UnaryCall } from "@protobuf-ts/runtime-rpc"; +import type { RpcOptions } from "@protobuf-ts/runtime-rpc"; +/** + * @generated from protobuf service ProcessWithCloudEvents.Grpc.Contract.GrpcTeacherStudentInteraction + */ +export interface IGrpcTeacherStudentInteractionClient { + /** + * @generated from protobuf rpc: StartProcess(ProcessWithCloudEvents.Grpc.Contract.ProcessDetails) returns (ProcessWithCloudEvents.Grpc.Contract.ProcessDetails); + */ + startProcess(input: ProcessDetails, options?: RpcOptions): UnaryCall; + /** + * @generated from protobuf rpc: RequestStudentAgentResponse(ProcessWithCloudEvents.Grpc.Contract.MessageContent) returns (ProcessWithCloudEvents.Grpc.Contract.MessageContent); + */ + requestStudentAgentResponse(input: MessageContent, options?: RpcOptions): UnaryCall; + /** + * @generated from protobuf rpc: ReceiveStudentAgentResponse(ProcessWithCloudEvents.Grpc.Contract.ProcessDetails) returns (stream ProcessWithCloudEvents.Grpc.Contract.MessageContent); + */ + receiveStudentAgentResponse(input: ProcessDetails, options?: RpcOptions): ServerStreamingCall; + /** + * @generated from protobuf rpc: PublishStudentAgentResponseFromProcess(ProcessWithCloudEvents.Grpc.Contract.MessageContent) returns (ProcessWithCloudEvents.Grpc.Contract.MessageContent); + */ + publishStudentAgentResponseFromProcess(input: MessageContent, options?: RpcOptions): UnaryCall; +} +/** + * @generated from protobuf service ProcessWithCloudEvents.Grpc.Contract.GrpcTeacherStudentInteraction + */ +export class GrpcTeacherStudentInteractionClient implements IGrpcTeacherStudentInteractionClient, ServiceInfo { + typeName = GrpcTeacherStudentInteraction.typeName; + methods = GrpcTeacherStudentInteraction.methods; + options = GrpcTeacherStudentInteraction.options; + constructor(private readonly _transport: RpcTransport) { + } + /** + * @generated from protobuf rpc: StartProcess(ProcessWithCloudEvents.Grpc.Contract.ProcessDetails) returns (ProcessWithCloudEvents.Grpc.Contract.ProcessDetails); + */ + startProcess(input: ProcessDetails, options?: RpcOptions): UnaryCall { + const method = this.methods[0], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } + /** + * @generated from protobuf rpc: RequestStudentAgentResponse(ProcessWithCloudEvents.Grpc.Contract.MessageContent) returns (ProcessWithCloudEvents.Grpc.Contract.MessageContent); + */ + requestStudentAgentResponse(input: MessageContent, options?: RpcOptions): UnaryCall { + const method = this.methods[1], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } + /** + * @generated from protobuf rpc: ReceiveStudentAgentResponse(ProcessWithCloudEvents.Grpc.Contract.ProcessDetails) returns (stream ProcessWithCloudEvents.Grpc.Contract.MessageContent); + */ + receiveStudentAgentResponse(input: ProcessDetails, options?: RpcOptions): ServerStreamingCall { + const method = this.methods[2], opt = this._transport.mergeOptions(options); + return stackIntercept("serverStreaming", this._transport, method, opt, input); + } + /** + * @generated from protobuf rpc: PublishStudentAgentResponseFromProcess(ProcessWithCloudEvents.Grpc.Contract.MessageContent) returns (ProcessWithCloudEvents.Grpc.Contract.MessageContent); + */ + publishStudentAgentResponseFromProcess(input: MessageContent, options?: RpcOptions): UnaryCall { + const method = this.methods[3], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/teacherStudentInteraction.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/teacherStudentInteraction.ts new file mode 100644 index 000000000000..7f0cef52ec96 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/gen/teacherStudentInteraction.ts @@ -0,0 +1,171 @@ +// @generated by protobuf-ts 2.9.6 with parameter generate_dependencies +// @generated from protobuf file "teacherStudentInteraction.proto" (package "ProcessWithCloudEvents.Grpc.Contract", syntax proto3) +// tslint:disable +import { ServiceType } from "@protobuf-ts/runtime-rpc"; +import type { BinaryWriteOptions } from "@protobuf-ts/runtime"; +import type { IBinaryWriter } from "@protobuf-ts/runtime"; +import { WireType } from "@protobuf-ts/runtime"; +import type { BinaryReadOptions } from "@protobuf-ts/runtime"; +import type { IBinaryReader } from "@protobuf-ts/runtime"; +import { UnknownFieldHandler } from "@protobuf-ts/runtime"; +import type { PartialMessage } from "@protobuf-ts/runtime"; +import { reflectionMergePartial } from "@protobuf-ts/runtime"; +import { MessageType } from "@protobuf-ts/runtime"; +/** + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.MessageContent + */ +export interface MessageContent { + /** + * @generated from protobuf field: ProcessWithCloudEvents.Grpc.Contract.User user = 1; + */ + user: User; + /** + * @generated from protobuf field: string content = 2; + */ + content: string; + /** + * @generated from protobuf field: string processId = 10; + */ + processId: string; +} +/** + * @generated from protobuf message ProcessWithCloudEvents.Grpc.Contract.ProcessDetails + */ +export interface ProcessDetails { + /** + * @generated from protobuf field: string processId = 1; + */ + processId: string; +} +/** + * @generated from protobuf enum ProcessWithCloudEvents.Grpc.Contract.User + */ +export enum User { + /** + * @generated from protobuf enum value: STUDENT = 0; + */ + STUDENT = 0, + /** + * @generated from protobuf enum value: TEACHER = 1; + */ + TEACHER = 1 +} +// @generated message type with reflection information, may provide speed optimized methods +class MessageContent$Type extends MessageType { + constructor() { + super("ProcessWithCloudEvents.Grpc.Contract.MessageContent", [ + { no: 1, name: "user", kind: "enum", T: () => ["ProcessWithCloudEvents.Grpc.Contract.User", User] }, + { no: 2, name: "content", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 10, name: "processId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): MessageContent { + const message = globalThis.Object.create((this.messagePrototype!)); + message.user = 0; + message.content = ""; + message.processId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MessageContent): MessageContent { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* ProcessWithCloudEvents.Grpc.Contract.User user */ 1: + message.user = reader.int32(); + break; + case /* string content */ 2: + message.content = reader.string(); + break; + case /* string processId */ 10: + message.processId = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: MessageContent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* ProcessWithCloudEvents.Grpc.Contract.User user = 1; */ + if (message.user !== 0) + writer.tag(1, WireType.Varint).int32(message.user); + /* string content = 2; */ + if (message.content !== "") + writer.tag(2, WireType.LengthDelimited).string(message.content); + /* string processId = 10; */ + if (message.processId !== "") + writer.tag(10, WireType.LengthDelimited).string(message.processId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message ProcessWithCloudEvents.Grpc.Contract.MessageContent + */ +export const MessageContent = new MessageContent$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ProcessDetails$Type extends MessageType { + constructor() { + super("ProcessWithCloudEvents.Grpc.Contract.ProcessDetails", [ + { no: 1, name: "processId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): ProcessDetails { + const message = globalThis.Object.create((this.messagePrototype!)); + message.processId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ProcessDetails): ProcessDetails { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string processId */ 1: + message.processId = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ProcessDetails, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string processId = 1; */ + if (message.processId !== "") + writer.tag(1, WireType.LengthDelimited).string(message.processId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message ProcessWithCloudEvents.Grpc.Contract.ProcessDetails + */ +export const ProcessDetails = new ProcessDetails$Type(); +/** + * @generated ServiceType for protobuf service ProcessWithCloudEvents.Grpc.Contract.GrpcTeacherStudentInteraction + */ +export const GrpcTeacherStudentInteraction = new ServiceType("ProcessWithCloudEvents.Grpc.Contract.GrpcTeacherStudentInteraction", [ + { name: "StartProcess", options: {}, I: ProcessDetails, O: ProcessDetails }, + { name: "RequestStudentAgentResponse", options: {}, I: MessageContent, O: MessageContent }, + { name: "ReceiveStudentAgentResponse", serverStreaming: true, options: {}, I: ProcessDetails, O: MessageContent }, + { name: "PublishStudentAgentResponseFromProcess", options: {}, I: MessageContent, O: MessageContent } +]); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/grpcClients.ts b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/grpcClients.ts new file mode 100644 index 000000000000..580952604e00 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/grpcClients.ts @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2025 Microsoft + * All rights reserved. + */ +import { GrpcWebFetchTransport } from "@protobuf-ts/grpcweb-transport"; +import { GrpcDocumentationGenerationClient } from "./gen/documentGeneration.client"; +import { GrpcTeacherStudentInteractionClient } from "./gen/teacherStudentInteraction.client"; + +// For this setup, both clients are using the same server URL - just different grpc services. +// In a real-world scenario, you might have different URLs for different services. +// This is just a placeholder URL. You should replace it with the actual URL of your gRPC server. +const SERVER_URL = "http://localhost:58640"; + +const getGrpcWebTransport = () => { + return new GrpcWebFetchTransport({ + baseUrl: SERVER_URL, + format: "text", + }); +}; + +const createGrpcDocGenerationClient = () => { + try { + const transport = getGrpcWebTransport(); + return new GrpcDocumentationGenerationClient(transport); + } catch (error) { + console.error( + "Could not create connection with gRPC server - document generation", + error + ); + return undefined; + } +}; + +export const grpcDocService = createGrpcDocGenerationClient(); + +const createGrpcTeacherStundentInteractionClient = () => { + try { + const transport = getGrpcWebTransport(); + return new GrpcTeacherStudentInteractionClient(transport); + } catch (error) { + console.error( + "Could not create connection with gRPC server - Teacher Student Interaction", + error + ); + return undefined; + } +}; + +export const grpcTeacherStudentService = + createGrpcTeacherStundentInteractionClient(); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/documentGeneration.proto b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/documentGeneration.proto index 2bd2800daa08..0d213fd70a4a 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/documentGeneration.proto +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/documentGeneration.proto @@ -1,6 +1,7 @@ syntax = "proto3"; -option csharp_namespace = "ProcessWithCloudEvents.Grpc.DocumentationGenerator"; +package ProcessWithCloudEvents.Grpc.Contract; +option csharp_namespace = "ProcessWithCloudEvents.Grpc.Contract"; service GrpcDocumentationGeneration { rpc UserRequestFeatureDocumentation (FeatureDocumentationRequest) returns (ProcessData); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/teacherStudentInteraction.proto b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/teacherStudentInteraction.proto new file mode 100644 index 000000000000..4a864b38caad --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client/src/services/grpc/proto/teacherStudentInteraction.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +package ProcessWithCloudEvents.Grpc.Contract; +option csharp_namespace = "ProcessWithCloudEvents.Grpc.Contract"; + +service GrpcTeacherStudentInteraction { + rpc StartProcess (ProcessDetails) returns (ProcessDetails); + rpc RequestStudentAgentResponse (MessageContent) returns (MessageContent); + rpc ReceiveStudentAgentResponse (ProcessDetails) returns (stream MessageContent); + rpc PublishStudentAgentResponseFromProcess (MessageContent) returns (MessageContent); +} + +enum User { + STUDENT = 0; + TEACHER = 1; +} + +message MessageContent { + User user = 1; + string content = 2; + string processId = 10; +} + +message ProcessDetails { + string processId = 1; +} \ No newline at end of file diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/ProcessWithCloudEvents.Grpc.LocalRuntime.csproj b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/ProcessWithCloudEvents.Grpc.LocalRuntime.csproj new file mode 100644 index 000000000000..325738226b54 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/ProcessWithCloudEvents.Grpc.LocalRuntime.csproj @@ -0,0 +1,43 @@ + + + + net8.0 + enable + enable + + $(NoWarn);CA2007,CS1591,CA1861,VSTHRD111,SKEXP0001,SKEXP0010,SKEXP0040,SKEXP0050,SKEXP0060,SKEXP0070,SKEXP0080,SKEXP0110 + + 5ee045b0-aea3-4f08-8d31-32d1a6f8fed0 + + + + + + + + + + + + + + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Program.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Program.cs new file mode 100644 index 000000000000..1dd631675f5c --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Program.cs @@ -0,0 +1,101 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.ClientModel; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Agents; +using Microsoft.SemanticKernel.Agents.OpenAI; +using OpenAI; +using ProcessWithCloudEvents.Grpc.Clients; +using ProcessWithCloudEvents.Grpc.Extensions; +using ProcessWithCloudEvents.Grpc.LocalRuntime.Services; +using ProcessWithCloudEvents.Processes; +using ProcessWithCloudEvents.SharedComponents.Options; +using ProcessWithCloudEvents.SharedComponents.Storage; + +var builder = WebApplication.CreateBuilder(args); + +var config = new ConfigurationBuilder() + .AddUserSecrets() + .AddEnvironmentVariables() + .Build(); + +// Configure logging +builder.Services.AddLogging((logging) => +{ + logging.AddConsole(); + logging.AddDebug(); +}); + +var openAIOptions = config.GetValid(OpenAIOptions.SectionName); +var cosmosDbOptions = config.GetValid(CosmosDBOptions.SectionName); + +// Configure the Kernel with DI. This is required for dependency injection to work with processes. +builder.Services.AddKernel(); +builder.Services.AddOpenAIChatCompletion(openAIOptions.ChatModelId, openAIOptions.ApiKey); + +// Setup for using Agent Steps in SK Process +var openAIClient = OpenAIAssistantAgent.CreateOpenAIClient(new ApiKeyCredential(openAIOptions.ApiKey)); +builder.Services.AddSingleton(openAIClient); +builder.Services.AddTransient(); + +// Grpc setup +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); + +// Since we have multiple grpc clients, we need to register them as keyed singletons so then we can access them respetively in each service by key +builder.Services.AddKeyedSingleton(DocumentGenerationGrpcClient.Key, (sp, key) => +{ + return new DocumentGenerationGrpcClient(); +}); +builder.Services.AddKeyedSingleton(TeacherStudentInteractionGrpcClient.Key, (sp, key) => +{ + return new TeacherStudentInteractionGrpcClient(); +}); + +// Configuring Processes to be used in this App +builder.Services.AddSingleton>(sp => +{ + var processes = new Dictionary + { + { DocumentGenerationProcess.Key, DocumentGenerationProcess.CreateProcessBuilder().Build() }, + { TeacherStudentProcess.Key, TeacherStudentProcess.CreateProcessBuilder().Build() } + }; + return processes; +}); + +// Registering storage used for persisting process state with Local Runtime +string tempDirectoryPath = Path.Combine(Path.GetTempPath(), "MySKProcessStorage"); +var storageInstance = new JsonFileStorage(tempDirectoryPath); + +var cloudStorageInstance = new CosmosDbProcessStorageConnector( + cosmosDbOptions.ConnectionString, cosmosDbOptions.DatabaseName, cosmosDbOptions.ContainerName +); + +//builder.Services.AddSingleton(storageInstance); +builder.Services.AddSingleton(cloudStorageInstance); + +// Enabling CORS for grpc-web when using webApp as client, remove if not needed +builder.Services.AddCors(o => o.AddPolicy("AllowAll", builder => +{ + builder.AllowAnyOrigin() + .AllowAnyMethod() + .AllowAnyHeader(); +})); + +// Add grpc related services. +builder.Services.AddGrpc(); +builder.Services.AddGrpcReflection(); + +var app = builder.Build(); + +app.UseCors(); + +// Grpc services mapping +// Enabling grpc-web, remove if not needed +app.UseGrpcWeb(); +// Enabling CORS for grpc-web, remove if not needed +app.MapGrpcReflectionService().RequireCors("AllowAll"); +app.MapGrpcService().EnableGrpcWeb().RequireCors("AllowAll"); +app.MapGrpcService().EnableGrpcWeb().RequireCors("AllowAll"); + +app.Run(); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Services/DocumentGenerationService.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Services/DocumentGenerationService.cs new file mode 100644 index 000000000000..9a7a8bc54314 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Services/DocumentGenerationService.cs @@ -0,0 +1,201 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Concurrent; +using Grpc.Core; +using Microsoft.SemanticKernel; +using Microsoft.VisualStudio.Threading; +using ProcessWithCloudEvents.Grpc.Clients; +using ProcessWithCloudEvents.Grpc.Contract; +using ProcessWithCloudEvents.Processes; +using ProcessWithCloudEvents.Processes.Models; + +namespace ProcessWithCloudEvents.Grpc.LocalRuntime.Services; + +/// +/// This gRPC service handles the generation of documents using/invoking a SK Process +/// +public class DocumentGenerationService : GrpcDocumentationGeneration.GrpcDocumentationGenerationBase +{ + private readonly ILogger _logger; + private readonly Kernel _kernel; + + private readonly IReadOnlyDictionary _registeredProcesses; + private readonly IExternalKernelProcessMessageChannel _externalMessageChannel; + private readonly IProcessStorageConnector _storageConnector; + + private readonly ConcurrentDictionary>> _docReviewSubscribers; + private readonly ConcurrentDictionary>> _publishDocumentSubscribers; + /// + /// Constructor for the + /// + /// + /// + /// + /// + /// + public DocumentGenerationService( + ILogger logger, + Kernel kernel, IReadOnlyDictionary registeredProcesses, + [FromKeyedServices("DocumentGenerationGrpcClient")] IExternalKernelProcessMessageChannel externalMessageChannel, + IProcessStorageConnector storageConnector) + { + this._logger = logger; + this._kernel = kernel; + this._docReviewSubscribers = new(); + this._publishDocumentSubscribers = new(); + + this._registeredProcesses = registeredProcesses; + this._externalMessageChannel = externalMessageChannel; + this._storageConnector = storageConnector; + } + + /// + /// Method that receives a request to generate documentation, this will start the SK process + /// defined in
+ /// It will use the processId passed in the request or generate a new one if not provided + /// + /// + /// + /// + public override async Task UserRequestFeatureDocumentation(FeatureDocumentationRequest request, ServerCallContext context) + { + var processId = string.IsNullOrEmpty(request.ProcessId) ? Guid.NewGuid().ToString() : request.ProcessId; + + var processContext = await LocalKernelProcessFactory.StartAsync(this._kernel, this._registeredProcesses, DocumentGenerationProcess.Key, processId, new KernelProcessEvent() + { + Id = DocumentGenerationProcess.DocGenerationEvents.StartDocumentGeneration, + // The object ProductInfo is sent because this is the type the GatherProductInfoStep is expecting + Data = new ProductInfo() { Title = request.Title, Content = request.Content, UserInput = request.UserDescription }, + }, externalMessageChannel: this._externalMessageChannel, storageConnector: this._storageConnector); + + return new ProcessData { ProcessId = processId }; + } + + /// + /// Method that receives a request to request user review of documentation, this will send a request to the client + /// if subscribed to the method previously with the same process id.
+ /// This method is meant to be used within the SK process from the implementation. + /// + /// + /// + /// + public override async Task RequestUserReviewDocumentationFromProcess(DocumentationContentRequest request, ServerCallContext context) + { + if (this._docReviewSubscribers.TryGetValue(request.ProcessData.ProcessId, out var subscribers)) + { + foreach (var subscriber in subscribers) + { + await subscriber.WriteAsync(request).ConfigureAwait(false); + } + } + + return new Empty(); + } + + /// + /// Method that receives request to receive user review of documentation.
+ /// This is meant to be used by the external client + /// + /// + /// + /// + /// + public override async Task RequestUserReviewDocumentation(ProcessData request, IServerStreamWriter responseStream, ServerCallContext context) + { + var subscribers = this._docReviewSubscribers.GetOrAdd(request.ProcessId, []); + subscribers.Add(responseStream); + + try + { + // Wait until the client disconnects + await context.CancellationToken.WaitHandle.ToTask(); + } + finally + { + // Remove the subscriber when client disconnects +#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type. + subscribers.TryTake(out responseStream); +#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type. + } + } + + /// + /// Method that receives a request to approve or reject documentation, this will send the response to the SK process. + /// This is meant to be used by the external client. + /// + /// + /// + /// + public override async Task UserReviewedDocumentation(DocumentationApprovalRequest request, ServerCallContext context) + { + KernelProcessEvent processEvent; + if (request.DocumentationApproved) + { + processEvent = new() + { + Id = DocumentGenerationProcess.DocGenerationEvents.UserApprovedDocument, + Data = true, + }; + } + else + { + processEvent = new() + { + Id = DocumentGenerationProcess.DocGenerationEvents.UserRejectedDocument, + Data = request.Reason, + }; + } + + var processContext = await LocalKernelProcessFactory.StartAsync(this._kernel, this._registeredProcesses, DocumentGenerationProcess.Key, request.ProcessData.ProcessId, processEvent, externalMessageChannel: this._externalMessageChannel, storageConnector: this._storageConnector); + + return new Empty(); + } + + /// + /// Method used to publish the generated documentation, this will send the documentation to the client + /// if subscribed to the method with the same process id.
+ /// This method is meant to be used within the SK process from the implementation. + /// + /// + /// + /// + public override async Task PublishDocumentation(DocumentationContentRequest request, ServerCallContext context) + { + if (this._publishDocumentSubscribers.TryGetValue(request.ProcessData.ProcessId, out var subscribers)) + { + foreach (var subscriber in subscribers) + { + await subscriber.WriteAsync(request).ConfigureAwait(false); + } + } + + return new Empty(); + } + + /// + /// Method that receives request to receive published documentation from a specific process id. + /// This is meant to be used by the external client. + /// + /// + /// + /// + /// + public override async Task ReceivePublishedDocumentation(ProcessData request, IServerStreamWriter responseStream, ServerCallContext context) + { + var subscribers = this._publishDocumentSubscribers.GetOrAdd(request.ProcessId, []); + subscribers.Add(responseStream); + + try + { + // Wait until the client disconnects + await context.CancellationToken.WaitHandle.ToTask(); + } + finally + { + // Remove the subscriber when client disconnects +#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type. + subscribers.TryTake(out responseStream); +#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type. + } + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Services/TeacherStudentInteractionService.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Services/TeacherStudentInteractionService.cs new file mode 100644 index 000000000000..73f585519edc --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/Services/TeacherStudentInteractionService.cs @@ -0,0 +1,106 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Concurrent; +using Grpc.Core; +using Microsoft.SemanticKernel; +using Microsoft.VisualStudio.Threading; +using ProcessWithCloudEvents.Grpc.Contract; +using ProcessWithCloudEvents.Processes; + +namespace ProcessWithCloudEvents.Grpc.LocalRuntime.Services; + +/// +/// This gRPC service handles a teacher student interaction using/invoking a SK Process +/// +public class TeacherStudentInteractionService : GrpcTeacherStudentInteraction.GrpcTeacherStudentInteractionBase +{ + private readonly ILogger _logger; + private readonly Kernel _kernel; + + private readonly IReadOnlyDictionary _registeredProcesses; + private readonly IExternalKernelProcessMessageChannel _externalMessageChannel; + private readonly IProcessStorageConnector _storageConnector; + + private readonly ConcurrentDictionary>> _studentMessagesSubscribers; + /// + /// Constructor for the + /// + /// + /// + /// + /// + /// + public TeacherStudentInteractionService( + ILogger logger, + Kernel kernel, IReadOnlyDictionary registeredProcesses, + [FromKeyedServices("TeacherStudentInteractionGrpcClient")] IExternalKernelProcessMessageChannel externalMessageChannel, + IProcessStorageConnector storageConnector) + { + this._logger = logger; + this._kernel = kernel; + this._studentMessagesSubscribers = new(); + + this._registeredProcesses = registeredProcesses; + this._externalMessageChannel = externalMessageChannel; + this._storageConnector = storageConnector; + } + + public override async Task StartProcess(ProcessDetails request, ServerCallContext context) + { + var processId = string.IsNullOrEmpty(request.ProcessId) ? Guid.NewGuid().ToString() : request.ProcessId; + + var processContext = await LocalKernelProcessFactory.StartAsync(this._kernel, this._registeredProcesses, TeacherStudentProcess.Key, processId, new KernelProcessEvent() + { + Id = TeacherStudentProcess.ProcessEvents.StartProcess, + Data = "Give me a welcome message with a brief summary of what you can do", + }, externalMessageChannel: this._externalMessageChannel, storageConnector: this._storageConnector); + + return new ProcessDetails { ProcessId = processId }; + } + + public override async Task ReceiveStudentAgentResponse(ProcessDetails request, IServerStreamWriter responseStream, ServerCallContext context) + { + var subscribers = this._studentMessagesSubscribers.GetOrAdd(request.ProcessId, []); + subscribers.Add(responseStream); + + try + { + // Wait until the client disconnects + await context.CancellationToken.WaitHandle.ToTask(); + } + finally + { + // Remove the subscriber when client disconnects +#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type. + subscribers.TryTake(out responseStream); +#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type. + } + } + + public override async Task PublishStudentAgentResponseFromProcess(MessageContent request, ServerCallContext context) + { + if (this._studentMessagesSubscribers.TryGetValue(request.ProcessId, out var subscribers)) + { + foreach (var subscriber in subscribers) + { + await subscriber.WriteAsync(request).ConfigureAwait(false); + } + } + + return request; + } + + public override async Task RequestStudentAgentResponse(MessageContent request, ServerCallContext context) + { + var process = TeacherStudentProcess.CreateProcessBuilder().Build(); + var processId = request.ProcessId; + + var processContext = await LocalKernelProcessFactory.StartAsync(this._kernel, this._registeredProcesses, TeacherStudentProcess.Key, processId, new KernelProcessEvent() + { + Id = TeacherStudentProcess.ProcessEvents.TeacherAskedQuestion, + Data = request.Content, + }, externalMessageChannel: this._externalMessageChannel, storageConnector: this._storageConnector); + + return request; + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/appsettings.json b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/appsettings.json new file mode 100644 index 000000000000..b42f98334964 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc.LocalRuntime/appsettings.json @@ -0,0 +1,21 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*", + "Kestrel": { + "Endpoints": { + "Http1": { + "Url": "http://*:58640", + "Protocols": "Http1" + }, + "Http2": { + "Url": "http://*:58641", + "Protocols": "Http2" + } + } + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/ProcessWithCloudEvents.Grpc.csproj b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/ProcessWithCloudEvents.Grpc.DaprRuntime.csproj similarity index 75% rename from dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/ProcessWithCloudEvents.Grpc.csproj rename to dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/ProcessWithCloudEvents.Grpc.DaprRuntime.csproj index b2d5022ffa34..baaa0bfdda46 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/ProcessWithCloudEvents.Grpc.csproj +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/ProcessWithCloudEvents.Grpc.DaprRuntime.csproj @@ -11,9 +11,13 @@ - + + + + + @@ -37,7 +41,7 @@ - + diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Program.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Program.cs index af71ba85206b..6e26c8d8c40d 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Program.cs +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Program.cs @@ -1,10 +1,15 @@ // Copyright (c) Microsoft. All rights reserved. +using System.ClientModel; using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Agents; +using Microsoft.SemanticKernel.Agents.OpenAI; +using OpenAI; using ProcessWithCloudEvents.Grpc.Clients; using ProcessWithCloudEvents.Grpc.Extensions; -using ProcessWithCloudEvents.Grpc.Options; using ProcessWithCloudEvents.Grpc.Services; +using ProcessWithCloudEvents.Processes; +using ProcessWithCloudEvents.SharedComponents.Options; var builder = WebApplication.CreateBuilder(args); @@ -26,17 +31,37 @@ builder.Services.AddKernel(); builder.Services.AddOpenAIChatCompletion(openAIOptions.ChatModelId, openAIOptions.ApiKey); +// Setup for using Agent Steps in SK Process +var openAIClient = OpenAIAssistantAgent.CreateOpenAIClient(new ApiKeyCredential(openAIOptions.ApiKey)); +builder.Services.AddSingleton(openAIClient); +builder.Services.AddTransient(); + +// Grpc setup builder.Services.AddSingleton(); +builder.Services.AddSingleton(); // Injecting SK Process custom grpc client IExternalKernelProcessMessageChannel implementation +// TODO: Add similar keyed singleton approach to support multiple grpc clients, for now uncomment/use only one grpc client at the time builder.Services.AddSingleton(); +//builder.Services.AddSingleton(); // Configure Dapr +builder.Services.AddDaprKernelProcesses(); builder.Services.AddActors(static options => { // Register the actors required to run Processes options.AddProcessActors(); }); +// Register the processes we want to run +builder.Services.AddKeyedSingleton(DocumentGenerationProcess.Key, (sp, key) => +{ + return DocumentGenerationProcess.CreateProcessBuilder().Build(); +}); +builder.Services.AddKeyedSingleton(TeacherStudentProcess.Key, (sp, key) => +{ + return TeacherStudentProcess.CreateProcessBuilder().Build(); +}); + // Enabling CORS for grpc-web when using webApp as client, remove if not needed builder.Services.AddCors(o => o.AddPolicy("AllowAll", builder => { @@ -59,6 +84,7 @@ // Enabling CORS for grpc-web, remove if not needed app.MapGrpcReflectionService().RequireCors("AllowAll"); app.MapGrpcService().EnableGrpcWeb().RequireCors("AllowAll"); +app.MapGrpcService().EnableGrpcWeb().RequireCors("AllowAll"); // Dapr actors related mapping app.MapActorsHandlers(); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/DocumentGenerationService.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/DocumentGenerationService.cs index 75fb235784c1..023384ea31cc 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/DocumentGenerationService.cs +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/DocumentGenerationService.cs @@ -6,7 +6,7 @@ using Microsoft.SemanticKernel; using Microsoft.VisualStudio.Threading; using ProcessWithCloudEvents.Grpc.Clients; -using ProcessWithCloudEvents.Grpc.DocumentationGenerator; +using ProcessWithCloudEvents.Grpc.Contract; using ProcessWithCloudEvents.Processes; using ProcessWithCloudEvents.Processes.Models; @@ -17,6 +17,7 @@ namespace ProcessWithCloudEvents.Grpc.Services; /// public class DocumentGenerationService : GrpcDocumentationGeneration.GrpcDocumentationGenerationBase { + private readonly DaprKernelProcessFactory _kernelProcessFactory; private readonly ILogger _logger; private readonly Kernel _kernel; private readonly IActorProxyFactory _actorProxyFactory; @@ -28,13 +29,15 @@ public class DocumentGenerationService : GrpcDocumentationGeneration.GrpcDocumen /// /// /// - public DocumentGenerationService(ILogger logger, Kernel kernel, IActorProxyFactory actorProxy) + /// + public DocumentGenerationService(ILogger logger, Kernel kernel, IActorProxyFactory actorProxy, DaprKernelProcessFactory kernelProcessFactory) { this._logger = logger; this._kernel = kernel; this._actorProxyFactory = actorProxy; this._docReviewSubscribers = new(); this._publishDocumentSubscribers = new(); + this._kernelProcessFactory = kernelProcessFactory; } /// @@ -50,13 +53,12 @@ public override async Task UserRequestFeatureDocumentation(FeatureD var processId = string.IsNullOrEmpty(request.ProcessId) ? Guid.NewGuid().ToString() : request.ProcessId; var process = DocumentGenerationProcess.CreateProcessBuilder().Build(); - var processContext = await process.StartAsync(new KernelProcessEvent() + var processContext = await this._kernelProcessFactory.StartAsync(DocumentGenerationProcess.Key, processId, new KernelProcessEvent() { Id = DocumentGenerationProcess.DocGenerationEvents.StartDocumentGeneration, // The object ProductInfo is sent because this is the type the GatherProductInfoStep is expecting Data = new ProductInfo() { Title = request.Title, Content = request.Content, UserInput = request.UserDescription }, }, - processId, this._actorProxyFactory); return new ProcessData { ProcessId = processId }; @@ -139,7 +141,7 @@ public override async Task UserReviewedDocumentation(DocumentationApprova }; } - var processContext = await process.StartAsync(processEvent, request.ProcessData.ProcessId); + var processContext = await this._kernelProcessFactory.StartAsync(DocumentGenerationProcess.Key, request.ProcessData.ProcessId, processEvent); return new Empty(); } diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/TeacherStudentInteractionService.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/TeacherStudentInteractionService.cs new file mode 100644 index 000000000000..464b41112479 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Services/TeacherStudentInteractionService.cs @@ -0,0 +1,101 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Concurrent; +using Dapr.Actors.Client; +using Grpc.Core; +using Microsoft.SemanticKernel; +using Microsoft.VisualStudio.Threading; +using ProcessWithCloudEvents.Grpc.Contract; +using ProcessWithCloudEvents.Processes; + +namespace ProcessWithCloudEvents.Grpc.Services; + +/// +/// This gRPC service handles the generation of documents using/invoking a SK Process +/// +public class TeacherStudentInteractionService : GrpcTeacherStudentInteraction.GrpcTeacherStudentInteractionBase +{ + private readonly DaprKernelProcessFactory _kernelProcessFactory; + private readonly ILogger _logger; + private readonly Kernel _kernel; + private readonly IActorProxyFactory _actorProxyFactory; + private readonly ConcurrentDictionary>> _studentMessagesSubscribers; + /// + /// Constructor for the + /// + /// + /// + /// + /// + public TeacherStudentInteractionService(ILogger logger, Kernel kernel, IActorProxyFactory actorProxy, DaprKernelProcessFactory kernelProcessFactory) + { + this._logger = logger; + this._kernel = kernel; + this._actorProxyFactory = actorProxy; + this._studentMessagesSubscribers = new(); + this._kernelProcessFactory = kernelProcessFactory; + } + + public override async Task StartProcess(ProcessDetails request, ServerCallContext context) + { + var processId = string.IsNullOrEmpty(request.ProcessId) ? Guid.NewGuid().ToString() : request.ProcessId; + // line below is no longer needed after addition of keyed processes + //var process = TeacherStudentProcess.CreateProcessBuilder().Build(); + + var processContext = await this._kernelProcessFactory.StartAsync(TeacherStudentProcess.Key, processId, new KernelProcessEvent() + { + Id = TeacherStudentProcess.ProcessEvents.StartProcess, + Data = "Give me a welcome message with a brief summary of what you can do", + }, + this._actorProxyFactory); + + return new ProcessDetails { ProcessId = processId }; + } + + public override async Task ReceiveStudentAgentResponse(ProcessDetails request, IServerStreamWriter responseStream, ServerCallContext context) + { + var subscribers = this._studentMessagesSubscribers.GetOrAdd(request.ProcessId, []); + subscribers.Add(responseStream); + + try + { + // Wait until the client disconnects + await context.CancellationToken.WaitHandle.ToTask(); + } + finally + { + // Remove the subscriber when client disconnects +#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type. + subscribers.TryTake(out responseStream); +#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type. + } + } + + public override async Task PublishStudentAgentResponseFromProcess(MessageContent request, ServerCallContext context) + { + if (this._studentMessagesSubscribers.TryGetValue(request.ProcessId, out var subscribers)) + { + foreach (var subscriber in subscribers) + { + await subscriber.WriteAsync(request).ConfigureAwait(false); + } + } + + return request; + } + + public override async Task RequestStudentAgentResponse(MessageContent request, ServerCallContext context) + { + var process = TeacherStudentProcess.CreateProcessBuilder().Build(); + var processId = request.ProcessId; + + var processContext = await this._kernelProcessFactory.StartAsync(DocumentGenerationProcess.Key, processId, new KernelProcessEvent() + { + Id = TeacherStudentProcess.ProcessEvents.TeacherAskedQuestion, + Data = request.Content, + }, + this._actorProxyFactory); + + return request; + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/DocumentGenerationProcess.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/DocumentGenerationProcess.cs index 6f319947c07a..fdfc8c7497fe 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/DocumentGenerationProcess.cs +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/DocumentGenerationProcess.cs @@ -10,6 +10,11 @@ namespace ProcessWithCloudEvents.Processes; /// public static class DocumentGenerationProcess { + /// + /// The key that the process will be registered with in the SK process runtime. + /// + public static string Key => nameof(DocumentGenerationProcess); + /// /// SK Process events emitted by /// @@ -72,9 +77,9 @@ public static ProcessBuilder CreateProcessBuilder(string processName = "Document .OnInputEvent(DocGenerationEvents.UserRejectedDocument) .SendEventTo(new(docsGenerationStep, functionName: GenerateDocumentationStep.ProcessFunctions.ApplySuggestions)); - processBuilder - .OnInputEvent(DocGenerationEvents.UserApprovedDocument) - .SendEventTo(new(docsPublishStep, parameterName: "userApproval")); + //processBuilder + // .OnInputEvent(DocGenerationEvents.UserApprovedDocument) + // .SendEventTo(new(docsPublishStep, parameterName: "userApproval")); // Hooking up the rest of the process steps infoGatheringStep @@ -93,8 +98,22 @@ public static ProcessBuilder CreateProcessBuilder(string processName = "Document // Additionally, the generated document is emitted externally for user approval using the pre-configured proxyStep docsProofreadStep .OnEvent(ProofReadDocumentationStep.OutputEvents.DocumentationApproved) - .EmitExternalEvent(proxyStep, DocGenerationTopics.RequestUserReview) - .SendEventTo(new ProcessFunctionTargetBuilder(docsPublishStep, parameterName: "document")); + .EmitExternalEvent(proxyStep, DocGenerationTopics.RequestUserReview); + //.SendEventTo(new ProcessFunctionTargetBuilder(docsPublishStep, parameterName: "document")); + + processBuilder + .ListenFor() + .AllOf([ + new(messageType: ProofReadDocumentationStep.OutputEvents.DocumentationApproved, docsProofreadStep), + new(messageType: DocGenerationEvents.UserApprovedDocument, processBuilder), + ]) + .SendEventTo(new ProcessStepTargetBuilder(docsPublishStep, inputMapping: (inputEvents) => + { + return new() { + { "document", inputEvents[docsProofreadStep.GetFullEventId(ProofReadDocumentationStep.OutputEvents.DocumentationApproved)] }, + { "userApproval", inputEvents[processBuilder.GetFullEventId(DocGenerationEvents.UserApprovedDocument)] }, + }; + })); // When event is approved by user, it gets published externally too docsPublishStep diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/ProcessWithCloudEvents.Processes.csproj b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/ProcessWithCloudEvents.Processes.csproj index 1fafc3012f07..4e004fa6b432 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/ProcessWithCloudEvents.Processes.csproj +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/ProcessWithCloudEvents.Processes.csproj @@ -10,6 +10,7 @@ + diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/TeacherStudentProcess.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/TeacherStudentProcess.cs new file mode 100644 index 000000000000..8b951fafe3e3 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Processes/TeacherStudentProcess.cs @@ -0,0 +1,99 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Agents.OpenAI; + +namespace ProcessWithCloudEvents.Processes; + +/// +/// Components related to the SK Process for generating documentation +/// +public static class TeacherStudentProcess +{ + /// + /// The key that the process will be registered with in the SK process runtime. + /// + public static string Key => nameof(TeacherStudentProcess); + + /// + /// SK Process events emitted by + /// + public static class ProcessEvents + { + /// + /// Event to start the document generation process + /// + public const string StartProcess = nameof(StartProcess); + /// + /// Event emitted when the user rejects the document + /// + public const string TeacherAskedQuestion = nameof(TeacherAskedQuestion); + } + + /// + /// SK Process topics emitted by + /// Topics are used to emit events to external systems + /// + public static class InteractionTopics + { + /// + /// Event emitted when the agent has a response + /// + public const string AgentResponseMessage = nameof(AgentResponseMessage); + + /// + /// Event emitted when the agent has an error + /// + public const string AgentErrorMessage = nameof(AgentErrorMessage); + } + + /// + /// Creates a process builder for the Document Generation SK Process + /// + /// name of the SK Process + /// instance of + public static ProcessBuilder CreateProcessBuilder(string processName = "TeacherStudentProcess") + { + // Create the process builder + ProcessBuilder processBuilder = new(processName); + + // Add the steps + var studentAgentStep = processBuilder.AddStepFromAgent( + new() + { + Name = "Student", + // On purpose not assigning AgentId, if not provided a new agent is created + Description = "Solves problem given", + Instructions = "Solve the problem given, if the question is repeated answer the question with a bit of humor emphasizing that the question was asked but still answering the question", + Model = new() + { + Id = "gpt-4o", + }, + Type = OpenAIAssistantAgentFactory.OpenAIAssistantAgentType, + }); + + var proxyStep = processBuilder.AddProxyStep(id: "proxy", [InteractionTopics.AgentResponseMessage, InteractionTopics.AgentErrorMessage]); + + // Orchestrate the external input events + processBuilder + .OnInputEvent(ProcessEvents.StartProcess) + //.SendEventTo(new(studentAgentStep, parameterName: "message")); + .SentToAgentStep(studentAgentStep); + + processBuilder + .OnInputEvent(ProcessEvents.TeacherAskedQuestion) + //.SendEventTo(new(studentAgentStep, parameterName: "message")); + .SentToAgentStep(studentAgentStep); + + studentAgentStep + .OnFunctionResult() + .EmitExternalEvent(proxyStep, InteractionTopics.AgentResponseMessage); + + studentAgentStep + .OnFunctionError() + .EmitExternalEvent(proxyStep, InteractionTopics.AgentErrorMessage) + .StopProcess(); + + return processBuilder; + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Extensions/ConfigurationExtension.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Extensions/ConfigurationExtension.cs similarity index 100% rename from dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Extensions/ConfigurationExtension.cs rename to dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Extensions/ConfigurationExtension.cs diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/ExtensionsUtilities.props b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/ExtensionsUtilities.props new file mode 100644 index 000000000000..58e2c5971538 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/ExtensionsUtilities.props @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Clients/DocumentGenerationGrpcClient.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Clients/DocumentGenerationGrpcClient.cs similarity index 96% rename from dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Clients/DocumentGenerationGrpcClient.cs rename to dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Clients/DocumentGenerationGrpcClient.cs index c87355c5f78d..87d4c92e9b25 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Clients/DocumentGenerationGrpcClient.cs +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Clients/DocumentGenerationGrpcClient.cs @@ -1,7 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using Grpc.Net.Client; using Microsoft.SemanticKernel; -using ProcessWithCloudEvents.Grpc.DocumentationGenerator; +using ProcessWithCloudEvents.Grpc.Contract; using ProcessWithCloudEvents.Processes; using ProcessWithCloudEvents.Processes.Models; @@ -14,6 +14,8 @@ namespace ProcessWithCloudEvents.Grpc.Clients; /// public class DocumentGenerationGrpcClient : IExternalKernelProcessMessageChannel { + public static string Key => nameof(DocumentGenerationGrpcClient); + private GrpcChannel? _grpcChannel; private GrpcDocumentationGeneration.GrpcDocumentationGenerationClient? _grpcClient; diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Clients/TeacherStudentInteractionGrpcClient.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Clients/TeacherStudentInteractionGrpcClient.cs new file mode 100644 index 000000000000..e84fa8705965 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Clients/TeacherStudentInteractionGrpcClient.cs @@ -0,0 +1,72 @@ +// Copyright (c) Microsoft. All rights reserved. +using Grpc.Net.Client; +using Microsoft.SemanticKernel; +using ProcessWithCloudEvents.Grpc.Contract; +using ProcessWithCloudEvents.Processes; + +namespace ProcessWithCloudEvents.Grpc.Clients; + +/// +/// Client that implements the interface used internally by the SK process +/// to emit events to external systems.
+/// This implementation is an example of a gRPC client that emits events to a gRPC server +/// +public class TeacherStudentInteractionGrpcClient : IExternalKernelProcessMessageChannel +{ + public static string Key => nameof(TeacherStudentInteractionGrpcClient); + + private GrpcChannel? _grpcChannel; + private GrpcTeacherStudentInteraction.GrpcTeacherStudentInteractionClient? _grpcClient; + + /// + public async ValueTask Initialize() + { + this._grpcChannel = GrpcChannel.ForAddress("http://localhost:58641"); + this._grpcClient = new GrpcTeacherStudentInteraction.GrpcTeacherStudentInteractionClient(this._grpcChannel); + } + + /// + public async ValueTask Uninitialize() + { + if (this._grpcChannel != null) + { + await this._grpcChannel.ShutdownAsync().ConfigureAwait(false); + } + } + + /// + public async Task EmitExternalEventAsync(string externalTopicEvent, KernelProcessProxyMessage message) + { + if (this._grpcClient != null && message.EventData != null) + { + switch (externalTopicEvent) + { + case TeacherStudentProcess.InteractionTopics.AgentResponseMessage: + var agentResponse = message.EventData.ToObject() as ChatMessageContent; + if (agentResponse != null) + { + await this._grpcClient.PublishStudentAgentResponseFromProcessAsync(new() + { + User = User.Student, + Content = agentResponse.Content, + ProcessId = message.ProcessId, + }); + } + return; + + case TeacherStudentProcess.InteractionTopics.AgentErrorMessage: + var agentErrorResponse = message.EventData.ToObject() as string; + if (agentErrorResponse != null) + { + await this._grpcClient.PublishStudentAgentResponseFromProcessAsync(new() + { + User = User.Student, + Content = $"ERROR: {agentErrorResponse}", + ProcessId = message.ProcessId, + }); + } + return; + } + } + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Protos/documentationGenerator.proto b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Proto/documentationGenerator.proto similarity index 90% rename from dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Protos/documentationGenerator.proto rename to dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Proto/documentationGenerator.proto index 2bd2800daa08..0d213fd70a4a 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Protos/documentationGenerator.proto +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Proto/documentationGenerator.proto @@ -1,6 +1,7 @@ syntax = "proto3"; -option csharp_namespace = "ProcessWithCloudEvents.Grpc.DocumentationGenerator"; +package ProcessWithCloudEvents.Grpc.Contract; +option csharp_namespace = "ProcessWithCloudEvents.Grpc.Contract"; service GrpcDocumentationGeneration { rpc UserRequestFeatureDocumentation (FeatureDocumentationRequest) returns (ProcessData); diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Proto/teacherStudentInteraction.proto b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Proto/teacherStudentInteraction.proto new file mode 100644 index 000000000000..4a864b38caad --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Grpc/Proto/teacherStudentInteraction.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +package ProcessWithCloudEvents.Grpc.Contract; +option csharp_namespace = "ProcessWithCloudEvents.Grpc.Contract"; + +service GrpcTeacherStudentInteraction { + rpc StartProcess (ProcessDetails) returns (ProcessDetails); + rpc RequestStudentAgentResponse (MessageContent) returns (MessageContent); + rpc ReceiveStudentAgentResponse (ProcessDetails) returns (stream MessageContent); + rpc PublishStudentAgentResponseFromProcess (MessageContent) returns (MessageContent); +} + +enum User { + STUDENT = 0; + TEACHER = 1; +} + +message MessageContent { + User user = 1; + string content = 2; + string processId = 10; +} + +message ProcessDetails { + string processId = 1; +} \ No newline at end of file diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/GrpcComponents.props b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/GrpcComponents.props new file mode 100644 index 000000000000..c013057b12ad --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/GrpcComponents.props @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Options/CosmosDBOptions.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Options/CosmosDBOptions.cs new file mode 100644 index 000000000000..15da381f4a85 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Options/CosmosDBOptions.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.ComponentModel.DataAnnotations; + +namespace ProcessWithCloudEvents.SharedComponents.Options; + +/// +/// Configuration for Cosmos DB. +/// +public class CosmosDBOptions +{ + public const string SectionName = "CosmosDB"; + + [Required] + public string ConnectionString { get; set; } = string.Empty; + + [Required] + public string DatabaseName { get; set; } = string.Empty; + + [Required] + public string ContainerName { get; set; } = string.Empty; +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Options/OpenAIOptions.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Options/OpenAIOptions.cs similarity index 87% rename from dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Options/OpenAIOptions.cs rename to dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Options/OpenAIOptions.cs index c6ef102d8555..eabe78412334 100644 --- a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Grpc/Options/OpenAIOptions.cs +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Options/OpenAIOptions.cs @@ -2,7 +2,7 @@ using System.ComponentModel.DataAnnotations; -namespace ProcessWithCloudEvents.Grpc.Options; +namespace ProcessWithCloudEvents.SharedComponents.Options; /// /// Configuration for OpenAI chat completion service. diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Storage/CosmosDbContainerStorageConnector.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Storage/CosmosDbContainerStorageConnector.cs new file mode 100644 index 000000000000..88a6cd5a81c8 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Storage/CosmosDbContainerStorageConnector.cs @@ -0,0 +1,108 @@ +// Copyright (c) Microsoft. All rights reserved. +#pragma warning disable IDE0005 // Using directive is unnecessary +using System.Collections.Concurrent; +using System.ComponentModel; +using System.Text.Json; +using Microsoft.Azure.Cosmos; +using Microsoft.SemanticKernel; +using Newtonsoft.Json; +#pragma warning restore IDE0005 // Using directive is unnecessary + +namespace ProcessWithCloudEvents.SharedComponents.Storage; + +internal sealed class CosmosDbProcessStorageConnector : IProcessStorageConnector, IDisposable +{ + // CosmosDB V3 has a dependency on Newtonsoft.Json, so need to add wrapper class for Cosmos DB entities: + // https://brettmckenzie.net/posts/the-input-content-is-invalid-because-the-required-properties-id-are-missing/ + internal sealed record CosmosDbEntity + { + [JsonProperty("id")] + public string Id { get; init; } = string.Empty; + + [JsonProperty("body")] + public T Body { get; init; } = default!; + + [JsonProperty("instanceId")] + public string PartitionKey { get; init; } = string.Empty; + } + + private readonly CosmosClient _cosmosClient; + private readonly Microsoft.Azure.Cosmos.Container _container; + private readonly string _databaseId; + private readonly string _containerId; + + public CosmosDbProcessStorageConnector(string connectionString, string databaseId, string containerId) + { + this._cosmosClient = new CosmosClient(connectionString); + this._databaseId = databaseId; + this._containerId = containerId; + this._container = this._cosmosClient.GetContainer(databaseId, containerId); + } + + public async ValueTask OpenConnectionAsync() + { + // Cosmos DB client handles connection pooling internally, so just ensure the client is initialized + await Task.CompletedTask; + } + + public async ValueTask CloseConnectionAsync() + { + // Dispose the CosmosClient to close connections + this._cosmosClient.Dispose(); + await Task.CompletedTask; + } + + public async Task GetEntryAsync(string id) where TEntry : class + { + try + { + var response = await this._container.ReadItemAsync>(id, new PartitionKey(id)); + return response.Resource.Body; + } + catch (CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound) + { + // Item not found + return null; + } + } + + public async Task SaveEntryAsync(string id, string type, TEntry entry) where TEntry : class + { + try + { + var wrappedEntry = new CosmosDbEntity + { + Id = id, + Body = entry, + PartitionKey = id + }; + await this._container.UpsertItemAsync(wrappedEntry, new PartitionKey(id)); + return true; + } + catch (CosmosException ex) + { + // Handle exceptions as needed, log them, etc. + Console.WriteLine($"Error saving entry: {ex.Message}"); + return false; + } + } + + public async Task DeleteEntryAsync(string id) + { + try + { + await this._container.DeleteItemAsync(id, new PartitionKey(id)); + return true; + } + catch (CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound) + { + // Item not found + return false; + } + } + + public void Dispose() + { + this._cosmosClient?.Dispose(); + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Storage/JsonFileStorage.cs b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Storage/JsonFileStorage.cs new file mode 100644 index 000000000000..f6657cb4a4f5 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/Storage/JsonFileStorage.cs @@ -0,0 +1,79 @@ +// Copyright (c) Microsoft. All rights reserved. +#pragma warning disable IDE0005 // Using directive is unnecessary +using System.Text.Json; +using Microsoft.SemanticKernel; +#pragma warning restore IDE0005 // Using directive is unnecessary + +namespace ProcessWithCloudEvents.SharedComponents.Storage; + +internal sealed class JsonFileStorage : IProcessStorageConnector +{ + private readonly string _storageDirectory; + + private readonly JsonSerializerOptions _jsonSerializerOptions = new() + { + WriteIndented = true, + }; + + public JsonFileStorage(string storageDirectory) + { + if (string.IsNullOrWhiteSpace(storageDirectory)) + { + throw new ArgumentException("Storage directory cannot be null or empty.", nameof(storageDirectory)); + } + + this._storageDirectory = storageDirectory; + Directory.CreateDirectory(this._storageDirectory); + } + + public async ValueTask OpenConnectionAsync() + { + // For file-based storage, there's no real "connection" to open. + // This method might be used to validate if the storage directory is accessible. + await Task.CompletedTask; + } + + public async ValueTask CloseConnectionAsync() + { + // For file-based storage, there's no real "connection" to close. + await Task.CompletedTask; + } + + private string GetFilePath(string id) + { + return Path.Combine(this._storageDirectory, $"{id}.json"); + } + + public async Task GetEntryAsync(string id) where TEntry : class + { + string filePath = this.GetFilePath(id); + if (!File.Exists(filePath)) + { + return null; + } + + string jsonData = await File.ReadAllTextAsync(filePath); + return JsonSerializer.Deserialize(jsonData); + } + + public async Task SaveEntryAsync(string id, string type, TEntry entry) where TEntry : class + { + string filePath = this.GetFilePath(id); + string jsonData = JsonSerializer.Serialize(entry, this._jsonSerializerOptions); + + await File.WriteAllTextAsync(filePath, jsonData); + return true; + } + + public Task DeleteEntryAsync(string id) + { + string filePath = this.GetFilePath(id); + if (File.Exists(filePath)) + { + File.Delete(filePath); + return Task.FromResult(true); + } + + return Task.FromResult(false); + } +} diff --git a/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/StorageComponents.props b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/StorageComponents.props new file mode 100644 index 000000000000..318a6c02708a --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Utilities/StorageComponents.props @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/dotnet/samples/Demos/ProcessWithDapr/CommonEvents.cs b/dotnet/samples/Demos/ProcessWithDapr/CommonEvents.cs new file mode 100644 index 000000000000..cb8e14e71706 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithDapr/CommonEvents.cs @@ -0,0 +1,17 @@ +// Copyright (c) Microsoft. All rights reserved. + +namespace ProcessWithDapr; + +internal static class CommonEvents +{ + public const string UserInputReceived = nameof(UserInputReceived); + public const string CompletionResponseGenerated = nameof(CompletionResponseGenerated); + public const string WelcomeDone = nameof(WelcomeDone); + public const string AStepDone = nameof(AStepDone); + public const string BStepDone = nameof(BStepDone); + public const string CStepDone = nameof(CStepDone); + public const string StartARequested = nameof(StartARequested); + public const string StartBRequested = nameof(StartBRequested); + public const string ExitRequested = nameof(ExitRequested); + public const string StartProcess = nameof(StartProcess); +} diff --git a/dotnet/samples/Demos/ProcessWithDapr/Controllers/ProcessController.cs b/dotnet/samples/Demos/ProcessWithDapr/Controllers/ProcessController.cs index efbd990cb692..9e174528f2ee 100644 --- a/dotnet/samples/Demos/ProcessWithDapr/Controllers/ProcessController.cs +++ b/dotnet/samples/Demos/ProcessWithDapr/Controllers/ProcessController.cs @@ -1,8 +1,8 @@ // Copyright (c) Microsoft. All rights reserved. -using System.Runtime.Serialization; using Microsoft.AspNetCore.Mvc; using Microsoft.SemanticKernel; +using ProcessWithDapr.Processes; namespace ProcessWithDapr.Controllers; @@ -10,17 +10,17 @@ namespace ProcessWithDapr.Controllers; /// A controller for chatbot. /// [ApiController] -public class ProcessController : ControllerBase +public partial class ProcessController : ControllerBase { - private readonly Kernel _kernel; + private readonly DaprKernelProcessFactory _kernelProcessFactory; /// /// Initializes a new instance of the class. /// - /// An instance of - public ProcessController(Kernel kernel) + /// An instance of + public ProcessController(DaprKernelProcessFactory daprKernelProcessFactory) { - this._kernel = kernel; + this._kernelProcessFactory = daprKernelProcessFactory ?? throw new ArgumentNullException(nameof(daprKernelProcessFactory)); } /// @@ -31,161 +31,10 @@ public ProcessController(Kernel kernel) [HttpGet("processes/{processId}")] public async Task PostAsync(string processId) { - var process = this.GetProcess(); - var processContext = await process.StartAsync(new KernelProcessEvent() { Id = CommonEvents.StartProcess }, processId: processId); - var finalState = await processContext.GetStateAsync(); - + var processContext = await this._kernelProcessFactory.StartAsync(ProcessWithCycle.Key, processId, new KernelProcessEvent() { Id = CommonEvents.StartProcess }); return this.Ok(processId); } - private KernelProcess GetProcess() - { - // Create the process builder. - ProcessBuilder processBuilder = new("ProcessWithDapr"); - - // Add some steps to the process. - var kickoffStep = processBuilder.AddStepFromType(); - var myAStep = processBuilder.AddStepFromType(); - var myBStep = processBuilder.AddStepFromType(); - - // ########## Configuring initial state on steps in a process ########### - // For demonstration purposes, we add the CStep and configure its initial state with a CurrentCycle of 1. - // Initializing state in a step can be useful for when you need a step to start out with a predetermines - // configuration that is not easily accomplished with dependency injection. - var myCStep = processBuilder.AddStepFromType(initialState: new() { CurrentCycle = 1 }); - - // Setup the input event that can trigger the process to run and specify which step and function it should be routed to. - processBuilder - .OnInputEvent(CommonEvents.StartProcess) - .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); - - // When the kickoff step is finished, trigger both AStep and BStep. - kickoffStep - .OnEvent(CommonEvents.StartARequested) - .SendEventTo(new ProcessFunctionTargetBuilder(myAStep)) - .SendEventTo(new ProcessFunctionTargetBuilder(myBStep)); - - // When AStep finishes, send its output to CStep. - myAStep - .OnEvent(CommonEvents.AStepDone) - .SendEventTo(new ProcessFunctionTargetBuilder(myCStep, parameterName: "astepdata")); - - // When BStep finishes, send its output to CStep also. - myBStep - .OnEvent(CommonEvents.BStepDone) - .SendEventTo(new ProcessFunctionTargetBuilder(myCStep, parameterName: "bstepdata")); - - // When CStep has finished without requesting an exit, activate the Kickoff step to start again. - myCStep - .OnEvent(CommonEvents.CStepDone) - .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); - - // When the CStep has finished by requesting an exit, stop the process. - myCStep - .OnEvent(CommonEvents.ExitRequested) - .StopProcess(); - - var process = processBuilder.Build(); - return process; - } - -#pragma warning disable CA1812 // Avoid uninstantiated internal classes - // These classes are dynamically instantiated by the processes used in tests. - - /// - /// Kick off step for the process. - /// - private sealed class KickoffStep : KernelProcessStep - { - public static class Functions - { - public const string KickOff = nameof(KickOff); - } - - [KernelFunction(Functions.KickOff)] - public async ValueTask PrintWelcomeMessageAsync(KernelProcessStepContext context) - { - Console.WriteLine("##### Kickoff ran."); - await context.EmitEventAsync(new() { Id = CommonEvents.StartARequested, Data = "Get Going" }); - } - } - - /// - /// A step in the process. - /// - private sealed class AStep : KernelProcessStep - { - [KernelFunction] - public async ValueTask DoItAsync(KernelProcessStepContext context) - { - Console.WriteLine("##### AStep ran."); - await Task.Delay(TimeSpan.FromSeconds(1)); - await context.EmitEventAsync(CommonEvents.AStepDone, "I did A"); - } - } - - /// - /// A step in the process. - /// - private sealed class BStep : KernelProcessStep - { - [KernelFunction] - public async ValueTask DoItAsync(KernelProcessStepContext context) - { - Console.WriteLine("##### BStep ran."); - await Task.Delay(TimeSpan.FromSeconds(2)); - await context.EmitEventAsync(new() { Id = CommonEvents.BStepDone, Data = "I did B" }); - } - } - - /// - /// A stateful step in the process. This step uses as the persisted - /// state object and overrides the ActivateAsync method to initialize the state when activated. - /// - private sealed class CStep : KernelProcessStep - { - private CStepState? _state; - - // ################ Using persisted state ################# - // CStep has state that we want to be persisted in the process. To ensure that the step always - // starts with the previously persisted or configured state, we need to override the ActivateAsync - // method and use the state object it provides. - public override ValueTask ActivateAsync(KernelProcessStepState state) - { - this._state = state.State!; - Console.WriteLine($"##### CStep activated with Cycle = '{state.State?.CurrentCycle}'."); - return base.ActivateAsync(state); - } - - [KernelFunction] - public async ValueTask DoItAsync(KernelProcessStepContext context, string astepdata, string bstepdata) - { - // ########### This method will restart the process in a loop until CurrentCycle >= 3 ########### - this._state!.CurrentCycle++; - if (this._state.CurrentCycle >= 3) - { - // Exit the processes - Console.WriteLine("##### CStep run cycle 3 - exiting."); - await context.EmitEventAsync(new() { Id = CommonEvents.ExitRequested }); - return; - } - - // Cycle back to the start - Console.WriteLine($"##### CStep run cycle {this._state.CurrentCycle}."); - await context.EmitEventAsync(new() { Id = CommonEvents.CStepDone }); - } - } - - /// - /// A state object for the CStep. - /// - [DataContract] - private sealed record CStepState - { - [DataMember] - public int CurrentCycle { get; set; } - } - /// /// Common Events used in the process. /// diff --git a/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/AStep.cs b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/AStep.cs new file mode 100644 index 000000000000..0d0a29070128 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/AStep.cs @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; + +namespace ProcessWithDapr.ProcessSteps; + +/// +/// A step in the process. +/// +internal sealed class AStep : KernelProcessStep +{ + [KernelFunction] + public async ValueTask DoItAsync(KernelProcessStepContext context) + { + Console.WriteLine("##### AStep ran."); + await Task.Delay(TimeSpan.FromSeconds(1)); + await context.EmitEventAsync(CommonEvents.AStepDone, "I did A"); + } +} diff --git a/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/BStep.cs b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/BStep.cs new file mode 100644 index 000000000000..12e91202fa53 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/BStep.cs @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; + +namespace ProcessWithDapr.ProcessSteps; + +/// +/// A step in the process. +/// +internal sealed class BStep : KernelProcessStep +{ + [KernelFunction] + public async ValueTask DoItAsync(KernelProcessStepContext context) + { + Console.WriteLine("##### BStep ran."); + await Task.Delay(TimeSpan.FromSeconds(2)); + await context.EmitEventAsync(new() { Id = CommonEvents.BStepDone, Data = "I did B" }); + } +} diff --git a/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/CStep.cs b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/CStep.cs new file mode 100644 index 000000000000..5dfc8242ceff --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/CStep.cs @@ -0,0 +1,54 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Runtime.Serialization; +using Microsoft.SemanticKernel; + +namespace ProcessWithDapr.ProcessSteps; + +/// +/// A stateful step in the process. This step uses as the persisted +/// state object and overrides the ActivateAsync method to initialize the state when activated. +/// +internal sealed class CStep : KernelProcessStep +{ + private CStepState? _state; + + // ################ Using persisted state ################# + // CStep has state that we want to be persisted in the process. To ensure that the step always + // starts with the previously persisted or configured state, we need to override the ActivateAsync + // method and use the state object it provides. + public override ValueTask ActivateAsync(KernelProcessStepState state) + { + this._state = state.State!; + Console.WriteLine($"##### CStep activated with Cycle = '{state.State?.CurrentCycle}'."); + return base.ActivateAsync(state); + } + + [KernelFunction] + public async ValueTask DoItAsync(KernelProcessStepContext context, string astepdata, string bstepdata) + { + // ########### This method will restart the process in a loop until CurrentCycle >= 3 ########### + this._state!.CurrentCycle++; + if (this._state.CurrentCycle >= 3) + { + // Exit the processes + Console.WriteLine("##### CStep run cycle 3 - exiting."); + await context.EmitEventAsync(new() { Id = CommonEvents.ExitRequested }); + return; + } + + // Cycle back to the start + Console.WriteLine($"##### CStep run cycle {this._state.CurrentCycle}."); + await context.EmitEventAsync(new() { Id = CommonEvents.CStepDone }); + } +} + +/// +/// A state object for the CStep. +/// +[DataContract] +internal sealed record CStepState +{ + [DataMember] + public int CurrentCycle { get; set; } +} diff --git a/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/KickoffStep.cs b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/KickoffStep.cs new file mode 100644 index 000000000000..24df1a2bc388 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithDapr/ProcessSteps/KickoffStep.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; + +namespace ProcessWithDapr.ProcessSteps; + +/// +/// Kick off step for the process. +/// +internal sealed class KickoffStep : KernelProcessStep +{ + public static class ProcessFunctions + { + public const string KickOff = nameof(KickOff); + } + + [KernelFunction(ProcessFunctions.KickOff)] + public async ValueTask PrintWelcomeMessageAsync(KernelProcessStepContext context) + { + Console.WriteLine("##### Kickoff ran."); + await context.EmitEventAsync(new() { Id = CommonEvents.StartARequested, Data = "Get Going" }); + } +} diff --git a/dotnet/samples/Demos/ProcessWithDapr/ProcessWithDapr.csproj b/dotnet/samples/Demos/ProcessWithDapr/ProcessWithDapr.csproj index d1bd90408672..c2156f50654c 100644 --- a/dotnet/samples/Demos/ProcessWithDapr/ProcessWithDapr.csproj +++ b/dotnet/samples/Demos/ProcessWithDapr/ProcessWithDapr.csproj @@ -9,9 +9,11 @@ - + - + diff --git a/dotnet/samples/Demos/ProcessWithDapr/Processes/ProcessWithCycle.cs b/dotnet/samples/Demos/ProcessWithDapr/Processes/ProcessWithCycle.cs new file mode 100644 index 000000000000..2ed530e1b6a8 --- /dev/null +++ b/dotnet/samples/Demos/ProcessWithDapr/Processes/ProcessWithCycle.cs @@ -0,0 +1,71 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; +using ProcessWithDapr.ProcessSteps; + +namespace ProcessWithDapr.Processes; + +internal static class ProcessWithCycle +{ + internal static string Key = "ProcessWithCycle"; + + internal static KernelProcess Build() + { + // Create the process builder. + ProcessBuilder processBuilder = new(ProcessWithCycle.Key); + + // Add some steps to the process. + var kickoffStep = processBuilder.AddStepFromType(); + var myAStep = processBuilder.AddStepFromType(); + var myBStep = processBuilder.AddStepFromType(); + + // ########## Configuring initial state on steps in a process ########### + // For demonstration purposes, we add the CStep and configure its initial state with a CurrentCycle of 1. + // Initializing state in a step can be useful for when you need a step to start out with a predetermines + // configuration that is not easily accomplished with dependency injection. + var myCStep = processBuilder.AddStepFromType(initialState: new() { CurrentCycle = 1 }); + + // Setup the input event that can trigger the process to run and specify which step and function it should be routed to. + processBuilder + .OnInputEvent(CommonEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); + + // When the kickoff step is finished, trigger both AStep and BStep. + kickoffStep + .OnEvent(CommonEvents.StartARequested) + .SendEventTo(new ProcessFunctionTargetBuilder(myAStep)) + .SendEventTo(new ProcessFunctionTargetBuilder(myBStep)); + + // When step A and step B have finished, trigger the CStep. + processBuilder + .ListenFor() + .AllOf(new() + { + new(messageType: CommonEvents.AStepDone, source: myAStep), + new(messageType: CommonEvents.BStepDone, source: myBStep) + }) + .SendEventTo(new ProcessStepTargetBuilder(myCStep, inputMapping: (inputEvents) => + { + // Map the input events to the CStep's input parameters. + // In this case, we are mapping the output of AStep to the first input parameter of CStep + // and the output of BStep to the second input parameter of CStep. + return new() + { + { "astepdata", inputEvents[$"{nameof(AStep)}.{CommonEvents.AStepDone}"] }, + { "bstepdata", inputEvents[$"{nameof(BStep)}.{CommonEvents.BStepDone}"] } + }; + })); + + // When CStep has finished without requesting an exit, activate the Kickoff step to start again. + myCStep + .OnEvent(CommonEvents.CStepDone) + .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); + + // When the CStep has finished by requesting an exit, stop the process. + myCStep + .OnEvent(CommonEvents.ExitRequested) + .StopProcess(); + + return processBuilder.Build(); + } +} diff --git a/dotnet/samples/Demos/ProcessWithDapr/Program.cs b/dotnet/samples/Demos/ProcessWithDapr/Program.cs index 4b2c0bdd2daf..7cee72f8cd83 100644 --- a/dotnet/samples/Demos/ProcessWithDapr/Program.cs +++ b/dotnet/samples/Demos/ProcessWithDapr/Program.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using Microsoft.SemanticKernel; +using ProcessWithDapr.Processes; var builder = WebApplication.CreateBuilder(args); @@ -15,12 +16,19 @@ builder.Services.AddKernel(); // Configure Dapr +builder.Services.AddDaprKernelProcesses(); builder.Services.AddActors(static options => { // Register the actors required to run Processes options.AddProcessActors(); }); +// Register the processes we want to run +builder.Services.AddKeyedSingleton(ProcessWithCycle.Key, (sp, key) => +{ + return ProcessWithCycle.Build(); +}); + builder.Services.AddControllers(); var app = builder.Build(); diff --git a/dotnet/samples/GettingStartedWithProcesses/GettingStartedWithProcesses.csproj b/dotnet/samples/GettingStartedWithProcesses/GettingStartedWithProcesses.csproj index 5e92c4906685..831ebbb9d6b4 100644 --- a/dotnet/samples/GettingStartedWithProcesses/GettingStartedWithProcesses.csproj +++ b/dotnet/samples/GettingStartedWithProcesses/GettingStartedWithProcesses.csproj @@ -10,8 +10,8 @@ - $(NoWarn);CS8618,IDE0009,IDE1006,CA1051,CA1050,CA1707,CA1054,CA2007,VSTHRD111,CS1591,RCS1110,RCS1243,CA5394,SKEXP0001,SKEXP0010,SKEXP0040,SKEXP0050,SKEXP0060,SKEXP0070,SKEXP0080,SKEXP0081,SKEXP0101,SKEXP0110,OPENAI001 - + $(NoWarn);CS8618,IDE0005,IDE0009,IDE1006,CA1051,CA1050,CA1707,CA1812,CA1054,CA2007,VSTHRD111,CS1591,RCS1110,RCS1243,CA5394,SKEXP0001,SKEXP0010,SKEXP0040,SKEXP0050,SKEXP0060,SKEXP0070,SKEXP0080,SKEXP0081,SKEXP0101,SKEXP0110,OPENAI001 + Library 5ee045b0-aea3-4f08-8d31-32d1a6f8fed0 @@ -38,20 +38,26 @@ + - + - - + + - - + + @@ -61,9 +67,23 @@ - - - + + + + + + + + + + + \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step01/Step01_Processes.cs b/dotnet/samples/GettingStartedWithProcesses/Step01/Step01_Processes.cs index 0c6f072ad03c..c77839e227dc 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step01/Step01_Processes.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step01/Step01_Processes.cs @@ -56,7 +56,7 @@ public async Task UseSimpleProcessAsync() // When the userInput step emits a user input event, send it to the assistantResponse step userInputStep .OnEvent(CommonEvents.UserInputReceived) - .SendEventTo(new ProcessFunctionTargetBuilder(responseStep, parameterName: "userMessage")); + .SendEventTo(new ProcessFunctionTargetBuilder(responseStep)); // When the assistantResponse step emits a response, send it to the userInput step responseStep @@ -68,9 +68,9 @@ public async Task UseSimpleProcessAsync() // Generate a Mermaid diagram for the process and print it to the console string mermaidGraph = kernelProcess.ToMermaid(); - Console.WriteLine($"=== Start - Mermaid Diagram for '{process.Name}' ==="); + Console.WriteLine($"=== Start - Mermaid Diagram for '{process.StepId}' ==="); Console.WriteLine(mermaidGraph); - Console.WriteLine($"=== End - Mermaid Diagram for '{process.Name}' ==="); + Console.WriteLine($"=== End - Mermaid Diagram for '{process.StepId}' ==="); // Generate an image from the Mermaid diagram string generatedImagePath = await MermaidRenderer.GenerateMermaidImageAsync(mermaidGraph, "ChatBotProcess.png"); diff --git a/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountCreationProcess.cs b/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountCreationProcess.cs index 74095b93d81f..86d970106d13 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountCreationProcess.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountCreationProcess.cs @@ -25,45 +25,54 @@ public static ProcessBuilder CreateProcess() // When the newCustomerForm is completed... process - .OnInputEvent(AccountOpeningEvents.NewCustomerFormCompleted) - // The information gets passed to the core system record creation step - .SendEventTo(new ProcessFunctionTargetBuilder(coreSystemRecordCreationStep, functionName: NewAccountStep.ProcessStepFunctions.CreateNewAccount, parameterName: "customerDetails")); - - // When the newCustomerForm is completed, the user interaction transcript with the user is passed to the core system record creation step - process - .OnInputEvent(AccountOpeningEvents.CustomerInteractionTranscriptReady) - .SendEventTo(new ProcessFunctionTargetBuilder(coreSystemRecordCreationStep, functionName: NewAccountStep.ProcessStepFunctions.CreateNewAccount, parameterName: "interactionTranscript")); - - // When the fraudDetectionCheck step passes, the information gets to core system record creation step to kickstart this step - process - .OnInputEvent(AccountOpeningEvents.NewAccountVerificationCheckPassed) - .SendEventTo(new ProcessFunctionTargetBuilder(coreSystemRecordCreationStep, functionName: NewAccountStep.ProcessStepFunctions.CreateNewAccount, parameterName: "previousCheckSucceeded")); + .ListenFor() + .AllOf( + [ + // When the newCustomerForm is completed, the new user form is passed to the core system record creation step + new(AccountOpeningEvents.NewCustomerFormCompleted, process), + // When the newCustomerForm is completed, the user interaction transcript with the user is passed to the core system record creation step + new(AccountOpeningEvents.CustomerInteractionTranscriptReady, process), + // When the fraudDetectionCheck step passes, the information gets to core system record creation step to kickstart this step + new(AccountOpeningEvents.NewAccountVerificationCheckPassed, process) + ]).SendEventTo(new ProcessStepTargetBuilder(coreSystemRecordCreationStep, inputMapping: (inputEvents) => + { + return new() + { + { "customerDetails", inputEvents[process.GetFullEventId(AccountOpeningEvents.NewCustomerFormCompleted)] }, + { "interactionTranscript", inputEvents[process.GetFullEventId(AccountOpeningEvents.CustomerInteractionTranscriptReady)] }, + { "previousCheckSucceeded", inputEvents[process.GetFullEventId(AccountOpeningEvents.NewAccountVerificationCheckPassed)] }, + }; + })); // When the coreSystemRecordCreation step successfully creates a new accountId, it will trigger the creation of a new marketing entry through the marketingRecordCreation step coreSystemRecordCreationStep .OnEvent(AccountOpeningEvents.NewMarketingRecordInfoReady) - .SendEventTo(new ProcessFunctionTargetBuilder(marketingRecordCreationStep, functionName: NewMarketingEntryStep.ProcessStepFunctions.CreateNewMarketingEntry, parameterName: "userDetails")); + .SendEventTo(new ProcessFunctionTargetBuilder(marketingRecordCreationStep)); // When the coreSystemRecordCreation step successfully creates a new accountId, it will trigger the creation of a new CRM entry through the crmRecord step coreSystemRecordCreationStep .OnEvent(AccountOpeningEvents.CRMRecordInfoReady) - .SendEventTo(new ProcessFunctionTargetBuilder(crmRecordStep, functionName: CRMRecordCreationStep.ProcessStepFunctions.CreateCRMEntry, parameterName: "userInteractionDetails")); + .SendEventTo(new ProcessFunctionTargetBuilder(crmRecordStep)); - // ParameterName is necessary when the step has multiple input arguments like welcomePacketStep.CreateWelcomePacketAsync - // When the coreSystemRecordCreation step successfully creates a new accountId, it will pass the account information details to the welcomePacket step - coreSystemRecordCreationStep - .OnEvent(AccountOpeningEvents.NewAccountDetailsReady) - .SendEventTo(new ProcessFunctionTargetBuilder(welcomePacketStep, parameterName: "accountDetails")); - - // When the marketingRecordCreation step successfully creates a new marketing entry, it will notify the welcomePacket step it is ready - marketingRecordCreationStep - .OnEvent(AccountOpeningEvents.NewMarketingEntryCreated) - .SendEventTo(new ProcessFunctionTargetBuilder(welcomePacketStep, parameterName: "marketingEntryCreated")); - - // When the crmRecord step successfully creates a new CRM entry, it will notify the welcomePacket step it is ready - crmRecordStep - .OnEvent(AccountOpeningEvents.CRMRecordInfoEntryCreated) - .SendEventTo(new ProcessFunctionTargetBuilder(welcomePacketStep, parameterName: "crmRecordCreated")); + process + .ListenFor() + .AllOf([ + // When the coreSystemRecordCreation step successfully creates a new accountId, it will pass the account information details to the welcomePacket step + new(AccountOpeningEvents.NewAccountDetailsReady, coreSystemRecordCreationStep), + // When the marketingRecordCreation step successfully creates a new marketing entry, it will notify the welcomePacket step it is ready + new(AccountOpeningEvents.NewMarketingEntryCreated, marketingRecordCreationStep), + // When the crmRecord step successfully creates a new CRM entry, it will notify the welcomePacket step it is ready + new(AccountOpeningEvents.CRMRecordInfoEntryCreated, crmRecordStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(welcomePacketStep, inputMapping: (inputEvents) => + { + return new() + { + { "accountDetails", inputEvents[coreSystemRecordCreationStep.GetFullEventId(AccountOpeningEvents.NewAccountDetailsReady)] }, + { "marketingEntryCreated", inputEvents[marketingRecordCreationStep.GetFullEventId(AccountOpeningEvents.NewMarketingEntryCreated)] }, + { "crmRecordCreated", inputEvents[crmRecordStep.GetFullEventId(AccountOpeningEvents.CRMRecordInfoEntryCreated)] }, + }; + })); return process; } diff --git a/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountVerificationProcess.cs b/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountVerificationProcess.cs index 41490e1a69b7..72a9c3964e44 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountVerificationProcess.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step02/Processes/NewAccountVerificationProcess.cs @@ -25,14 +25,24 @@ public static ProcessBuilder CreateProcess() process .OnInputEvent(AccountOpeningEvents.NewCustomerFormCompleted) // The information gets passed to the core system record creation step - .SendEventTo(new ProcessFunctionTargetBuilder(customerCreditCheckStep, functionName: CreditScoreCheckStep.ProcessStepFunctions.DetermineCreditScore, parameterName: "customerDetails")) - // The information gets passed to the fraud detection step for validation - .SendEventTo(new ProcessFunctionTargetBuilder(fraudDetectionCheckStep, functionName: FraudDetectionStep.ProcessStepFunctions.FraudDetectionCheck, parameterName: "customerDetails")); + .SendEventTo(new ProcessFunctionTargetBuilder(customerCreditCheckStep, functionName: CreditScoreCheckStep.ProcessStepFunctions.DetermineCreditScore)); - // When the creditScoreCheck step results in Approval, the information gets to the fraudDetection step to kickstart this step - customerCreditCheckStep - .OnEvent(AccountOpeningEvents.CreditScoreCheckApproved) - .SendEventTo(new ProcessFunctionTargetBuilder(fraudDetectionCheckStep, functionName: FraudDetectionStep.ProcessStepFunctions.FraudDetectionCheck, parameterName: "previousCheckSucceeded")); + process.ListenFor().AllOf( + [ + // When the newCustomerForm is completed the information gets passed to the fraud detection step for validation + new(AccountOpeningEvents.NewCustomerFormCompleted, process), + // When the creditScoreCheck step results in Approval, the information gets to the fraudDetection step to kickstart this step + new(AccountOpeningEvents.CreditScoreCheckApproved, customerCreditCheckStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(fraudDetectionCheckStep, inputMapping: (inputEvents) => + { + // The fraud detection step needs the customer details and the credit score check result + return new() + { + { "customerDetails", inputEvents[process.GetFullEventId(AccountOpeningEvents.NewCustomerFormCompleted)] }, + { "previousCheckSucceeded", inputEvents[customerCreditCheckStep.GetFullEventId(AccountOpeningEvents.CreditScoreCheckApproved)] } + }; + })); return process; } diff --git a/dotnet/samples/GettingStartedWithProcesses/Step02/Step02a_AccountOpening.cs b/dotnet/samples/GettingStartedWithProcesses/Step02/Step02a_AccountOpening.cs index e8dc106928b9..fd33e11ca0f3 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step02/Step02a_AccountOpening.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step02/Step02a_AccountOpening.cs @@ -45,7 +45,7 @@ private KernelProcess SetupAccountOpeningProcess() where TUserIn // Function names are necessary when the step has multiple public functions like CompleteNewCustomerFormStep: NewAccountWelcome and NewAccountProcessUserInfo userInputStep .OnEvent(CommonEvents.UserInputReceived) - .SendEventTo(new ProcessFunctionTargetBuilder(newCustomerFormStep, CompleteNewCustomerFormStep.ProcessStepFunctions.NewAccountProcessUserInfo, "userMessage")); + .SendEventTo(new ProcessFunctionTargetBuilder(newCustomerFormStep, CompleteNewCustomerFormStep.ProcessStepFunctions.NewAccountProcessUserInfo)); userInputStep .OnEvent(CommonEvents.Exit) @@ -64,68 +64,90 @@ private KernelProcess SetupAccountOpeningProcess() where TUserIn // When the newCustomerForm is completed... newCustomerFormStep .OnEvent(AccountOpeningEvents.NewCustomerFormCompleted) - // The information gets passed to the core system record creation step - .SendEventTo(new ProcessFunctionTargetBuilder(customerCreditCheckStep, functionName: CreditScoreCheckStep.ProcessStepFunctions.DetermineCreditScore, parameterName: "customerDetails")) - // The information gets passed to the fraud detection step for validation - .SendEventTo(new ProcessFunctionTargetBuilder(fraudDetectionCheckStep, functionName: FraudDetectionStep.ProcessStepFunctions.FraudDetectionCheck, parameterName: "customerDetails")) - // The information gets passed to the core system record creation step - .SendEventTo(new ProcessFunctionTargetBuilder(coreSystemRecordCreationStep, functionName: NewAccountStep.ProcessStepFunctions.CreateNewAccount, parameterName: "customerDetails")); - - // When the newCustomerForm is completed, the user interaction transcript with the user is passed to the core system record creation step - newCustomerFormStep - .OnEvent(AccountOpeningEvents.CustomerInteractionTranscriptReady) - .SendEventTo(new ProcessFunctionTargetBuilder(coreSystemRecordCreationStep, functionName: NewAccountStep.ProcessStepFunctions.CreateNewAccount, parameterName: "interactionTranscript")); + // The information gets passed to the credit check step record creation step + .SendEventTo(new ProcessFunctionTargetBuilder(customerCreditCheckStep, functionName: CreditScoreCheckStep.ProcessStepFunctions.DetermineCreditScore)); // When the creditScoreCheck step results in Rejection, the information gets to the mailService step to notify the user about the state of the application and the reasons customerCreditCheckStep .OnEvent(AccountOpeningEvents.CreditScoreCheckRejected) - .SendEventTo(new ProcessFunctionTargetBuilder(mailServiceStep, functionName: MailServiceStep.ProcessStepFunctions.SendMailToUserWithDetails, parameterName: "message")); - - // When the creditScoreCheck step results in Approval, the information gets to the fraudDetection step to kickstart this step - customerCreditCheckStep - .OnEvent(AccountOpeningEvents.CreditScoreCheckApproved) - .SendEventTo(new ProcessFunctionTargetBuilder(fraudDetectionCheckStep, functionName: FraudDetectionStep.ProcessStepFunctions.FraudDetectionCheck, parameterName: "previousCheckSucceeded")); + .SendEventTo(new ProcessFunctionTargetBuilder(mailServiceStep)); + + process + .ListenFor() + .AllOf([ + // When the newCustomerForm is completed the information gets passed to the fraud detection step for validation + new(AccountOpeningEvents.NewCustomerFormCompleted, newCustomerFormStep), + // When the creditScoreCheck step results in Approval, the information gets to the fraudDetection step to kickstart this step + new(AccountOpeningEvents.CreditScoreCheckApproved, customerCreditCheckStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(fraudDetectionCheckStep, inputMapping: (inputEvents) => + { + return new() + { + { "customerDetails", inputEvents[newCustomerFormStep.GetFullEventId(AccountOpeningEvents.NewCustomerFormCompleted)] }, + { "previousCheckSucceeded", inputEvents[customerCreditCheckStep.GetFullEventId(AccountOpeningEvents.CreditScoreCheckApproved)] }, + }; + })); // When the fraudDetectionCheck step fails, the information gets to the mailService step to notify the user about the state of the application and the reasons fraudDetectionCheckStep .OnEvent(AccountOpeningEvents.FraudDetectionCheckFailed) - .SendEventTo(new ProcessFunctionTargetBuilder(mailServiceStep, functionName: MailServiceStep.ProcessStepFunctions.SendMailToUserWithDetails, parameterName: "message")); - - // When the fraudDetectionCheck step passes, the information gets to core system record creation step to kickstart this step - fraudDetectionCheckStep - .OnEvent(AccountOpeningEvents.FraudDetectionCheckPassed) - .SendEventTo(new ProcessFunctionTargetBuilder(coreSystemRecordCreationStep, functionName: NewAccountStep.ProcessStepFunctions.CreateNewAccount, parameterName: "previousCheckSucceeded")); + .SendEventTo(new ProcessFunctionTargetBuilder(mailServiceStep)); + + process + .ListenFor() + .AllOf( + [ + // When the newCustomerForm is completed, the information gets passed to the core system record creation step + new(AccountOpeningEvents.NewCustomerFormCompleted, newCustomerFormStep), + // When the newCustomerForm is completed, the user interaction transcript with the user is passed to the core system record creation step + new(AccountOpeningEvents.CustomerInteractionTranscriptReady, newCustomerFormStep), + // When the fraudDetectionCheck step passes, the information gets to core system record creation step to kickstart this step + new(AccountOpeningEvents.FraudDetectionCheckPassed, fraudDetectionCheckStep), + ]).SendEventTo(new ProcessStepTargetBuilder(coreSystemRecordCreationStep, inputMapping: (inputEvents) => + { + return new() + { + { "customerDetails", inputEvents[newCustomerFormStep.GetFullEventId(AccountOpeningEvents.NewCustomerFormCompleted)] }, + { "interactionTranscript", inputEvents[newCustomerFormStep.GetFullEventId(AccountOpeningEvents.CustomerInteractionTranscriptReady)] }, + { "previousCheckSucceeded", inputEvents[fraudDetectionCheckStep.GetFullEventId(AccountOpeningEvents.FraudDetectionCheckPassed)] }, + }; + })); // When the coreSystemRecordCreation step successfully creates a new accountId, it will trigger the creation of a new marketing entry through the marketingRecordCreation step coreSystemRecordCreationStep .OnEvent(AccountOpeningEvents.NewMarketingRecordInfoReady) - .SendEventTo(new ProcessFunctionTargetBuilder(marketingRecordCreationStep, functionName: NewMarketingEntryStep.ProcessStepFunctions.CreateNewMarketingEntry, parameterName: "userDetails")); + .SendEventTo(new ProcessFunctionTargetBuilder(marketingRecordCreationStep)); // When the coreSystemRecordCreation step successfully creates a new accountId, it will trigger the creation of a new CRM entry through the crmRecord step coreSystemRecordCreationStep .OnEvent(AccountOpeningEvents.CRMRecordInfoReady) - .SendEventTo(new ProcessFunctionTargetBuilder(crmRecordStep, functionName: CRMRecordCreationStep.ProcessStepFunctions.CreateCRMEntry, parameterName: "userInteractionDetails")); - - // ParameterName is necessary when the step has multiple input arguments like welcomePacketStep.CreateWelcomePacketAsync - // When the coreSystemRecordCreation step successfully creates a new accountId, it will pass the account information details to the welcomePacket step - coreSystemRecordCreationStep - .OnEvent(AccountOpeningEvents.NewAccountDetailsReady) - .SendEventTo(new ProcessFunctionTargetBuilder(welcomePacketStep, parameterName: "accountDetails")); - - // When the marketingRecordCreation step successfully creates a new marketing entry, it will notify the welcomePacket step it is ready - marketingRecordCreationStep - .OnEvent(AccountOpeningEvents.NewMarketingEntryCreated) - .SendEventTo(new ProcessFunctionTargetBuilder(welcomePacketStep, parameterName: "marketingEntryCreated")); - - // When the crmRecord step successfully creates a new CRM entry, it will notify the welcomePacket step it is ready - crmRecordStep - .OnEvent(AccountOpeningEvents.CRMRecordInfoEntryCreated) - .SendEventTo(new ProcessFunctionTargetBuilder(welcomePacketStep, parameterName: "crmRecordCreated")); + .SendEventTo(new ProcessFunctionTargetBuilder(crmRecordStep)); + + process + .ListenFor() + .AllOf([ + // When the coreSystemRecordCreation step successfully creates a new accountId, it will pass the account information details to the welcomePacket step + new(AccountOpeningEvents.NewAccountDetailsReady, coreSystemRecordCreationStep), + // When the marketingRecordCreation step successfully creates a new marketing entry, it will notify the welcomePacket step it is ready + new(AccountOpeningEvents.NewMarketingEntryCreated, marketingRecordCreationStep), + // When the crmRecord step successfully creates a new CRM entry, it will notify the welcomePacket step it is ready + new(AccountOpeningEvents.CRMRecordInfoEntryCreated, crmRecordStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(welcomePacketStep, inputMapping: (inputEvents) => + { + return new() + { + { "accountDetails", inputEvents[coreSystemRecordCreationStep.GetFullEventId(AccountOpeningEvents.NewAccountDetailsReady)] }, + { "marketingEntryCreated", inputEvents[marketingRecordCreationStep.GetFullEventId(AccountOpeningEvents.NewMarketingEntryCreated)] }, + { "crmRecordCreated", inputEvents[crmRecordStep.GetFullEventId(AccountOpeningEvents.CRMRecordInfoEntryCreated)] }, + }; + })); // After crmRecord and marketing gets created, a welcome packet is created to then send information to the user with the mailService step welcomePacketStep .OnEvent(AccountOpeningEvents.WelcomePacketCreated) - .SendEventTo(new ProcessFunctionTargetBuilder(mailServiceStep, functionName: MailServiceStep.ProcessStepFunctions.SendMailToUserWithDetails, parameterName: "message")); + .SendEventTo(new ProcessFunctionTargetBuilder(mailServiceStep)); // All possible paths end up with the user being notified about the account creation decision throw the mailServiceStep completion mailServiceStep diff --git a/dotnet/samples/GettingStartedWithProcesses/Step02/Step02b_AccountOpening.cs b/dotnet/samples/GettingStartedWithProcesses/Step02/Step02b_AccountOpening.cs index 15e6fc692701..61a6e8c41748 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step02/Step02b_AccountOpening.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step02/Step02b_AccountOpening.cs @@ -45,7 +45,7 @@ private KernelProcess SetupAccountOpeningProcess() where TUserIn // Function names are necessary when the step has multiple public functions like CompleteNewCustomerFormStep: NewAccountWelcome and NewAccountProcessUserInfo userInputStep .OnEvent(CommonEvents.UserInputReceived) - .SendEventTo(new ProcessFunctionTargetBuilder(newCustomerFormStep, CompleteNewCustomerFormStep.ProcessStepFunctions.NewAccountProcessUserInfo, "userMessage")); + .SendEventTo(new ProcessFunctionTargetBuilder(newCustomerFormStep, CompleteNewCustomerFormStep.ProcessStepFunctions.NewAccountProcessUserInfo)); userInputStep .OnEvent(CommonEvents.Exit) diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/Processes/FishAndChipsProcess.cs b/dotnet/samples/GettingStartedWithProcesses/Step03/Processes/FishAndChipsProcess.cs index 67a7fbc863ef..5979fba627b4 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/Processes/FishAndChipsProcess.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/Processes/FishAndChipsProcess.cs @@ -34,13 +34,16 @@ public static ProcessBuilder CreateProcess(string processName = "FishAndChipsPro .SendEventTo(makeFriedFishStep.WhereInputEventIs(FriedFishProcess.ProcessEvents.PrepareFriedFish)) .SendEventTo(makePotatoFriesStep.WhereInputEventIs(PotatoFriesProcess.ProcessEvents.PreparePotatoFries)); - makeFriedFishStep - .OnEvent(FriedFishProcess.ProcessEvents.FriedFishReady) - .SendEventTo(new ProcessFunctionTargetBuilder(addCondimentsStep, parameterName: "fishActions")); - - makePotatoFriesStep - .OnEvent(PotatoFriesProcess.ProcessEvents.PotatoFriesReady) - .SendEventTo(new ProcessFunctionTargetBuilder(addCondimentsStep, parameterName: "potatoActions")); + processBuilder.ListenFor().AllOf([ + new(FriedFishProcess.ProcessEvents.FriedFishReady, makeFriedFishStep), + new(PotatoFriesProcess.ProcessEvents.PotatoFriesReady, makePotatoFriesStep), + ]).SendEventTo(new ProcessStepTargetBuilder(addCondimentsStep, inputMapping: inputEvents => + { + return new() { + { "fishActions", inputEvents[makeFriedFishStep.GetFullEventId(FriedFishProcess.ProcessEvents.FriedFishReady)] }, + { "potatoActions", inputEvents[makePotatoFriesStep.GetFullEventId(PotatoFriesProcess.ProcessEvents.PotatoFriesReady)] }, + }; + })); addCondimentsStep .OnEvent(AddFishAndChipsCondimentsStep.OutputEvents.CondimentsAdded) @@ -63,13 +66,17 @@ public static ProcessBuilder CreateProcessWithStatefulSteps(string processName = .SendEventTo(makeFriedFishStep.WhereInputEventIs(FriedFishProcess.ProcessEvents.PrepareFriedFish)) .SendEventTo(makePotatoFriesStep.WhereInputEventIs(PotatoFriesProcess.ProcessEvents.PreparePotatoFries)); - makeFriedFishStep - .OnEvent(FriedFishProcess.ProcessEvents.FriedFishReady) - .SendEventTo(new ProcessFunctionTargetBuilder(addCondimentsStep, parameterName: "fishActions")); - - makePotatoFriesStep - .OnEvent(PotatoFriesProcess.ProcessEvents.PotatoFriesReady) - .SendEventTo(new ProcessFunctionTargetBuilder(addCondimentsStep, parameterName: "potatoActions")); + processBuilder.ListenFor().AllOf( + [ + new(FriedFishProcess.ProcessEvents.FriedFishReady, makeFriedFishStep), + new(PotatoFriesProcess.ProcessEvents.PotatoFriesReady, makePotatoFriesStep), + ]).SendEventTo(new ProcessStepTargetBuilder(addCondimentsStep, inputMapping: inputEvents => + { + return new() { + { "fishActions", inputEvents[makeFriedFishStep.GetFullEventId(FriedFishProcess.ProcessEvents.FriedFishReady)] }, + { "potatoActions", inputEvents[makePotatoFriesStep.GetFullEventId(PotatoFriesProcess.ProcessEvents.PotatoFriesReady)] }, + }; + })); addCondimentsStep .OnEvent(AddFishAndChipsCondimentsStep.OutputEvents.CondimentsAdded) diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FishSandwichStateProcessSuccess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FishSandwichStateProcessSuccess.json deleted file mode 100644 index b675988eda82..000000000000 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FishSandwichStateProcessSuccess.json +++ /dev/null @@ -1,54 +0,0 @@ -{ - "stepsState": { - "FriedFishWithStatefulStepsProcess": { - "$type": "Process", - "stepsState": { - "GatherFriedFishIngredientsWithStockStep": { - "$type": "Step", - "id": "7d4c02d000a744f490f2b5f9bad721fb", - "name": "GatherFriedFishIngredientsWithStockStep", - "versionInfo": "GatherFishIngredient.V2", - "state": { - "IngredientsStock": 2 - } - }, - "CutFoodStep": { - "$type": "Step", - "id": "f147010a57d34587a3dc1ed4677e5163", - "name": "CutFoodStep", - "versionInfo": "CutFoodStep.V1" - }, - "FryFoodStep": { - "$type": "Step", - "id": "78cc5af4106549afb74d7a6813016f87", - "name": "FryFoodStep", - "versionInfo": "FryFoodStep.V1" - } - }, - "id": "282717158b9f49e5b1acce81429610e0", - "name": "FriedFishWithStatefulStepsProcess", - "versionInfo": "FriedFishProcess.v1" - }, - "AddBunsStep": { - "$type": "Step", - "id": "31e953154e574470911d168a39588ed8", - "name": "AddBunsStep", - "versionInfo": "v1" - }, - "AddSpecialSauceStep": { - "$type": "Step", - "id": "67ee29ff28e4446d8046417675ec21e8", - "name": "AddSpecialSauceStep", - "versionInfo": "v1" - }, - "ExternalFriedFishStep": { - "$type": "Step", - "id": "873b1c8dee45412e975a5e8db2ed0b43", - "name": "ExternalFriedFishStep", - "versionInfo": "v1" - } - }, - "id": "af40089f-e57b-46d1-a15b-40c0d7f3800f", - "name": "FishSandwichWithStatefulStepsProcess", - "versionInfo": "FishSandwich.V1" -} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FishSandwichStateProcessSuccessLowStock.json b/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FishSandwichStateProcessSuccessLowStock.json deleted file mode 100644 index 9af1d9c1763b..000000000000 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FishSandwichStateProcessSuccessLowStock.json +++ /dev/null @@ -1,55 +0,0 @@ -{ - "$type": "Process", - "stepsState": { - "FriedFishWithStatefulStepsProcess": { - "$type": "Process", - "stepsState": { - "GatherFriedFishIngredientsWithStockStep": { - "$type": "Step", - "id": "2908f8c88cf0476a8e0075c3a8020d5d", - "name": "GatherFriedFishIngredientsWithStockStep", - "versionInfo": "GatherFishIngredient.V2", - "state": { - "IngredientsStock": 1 - } - }, - "CutFoodStep": { - "$type": "Step", - "id": "014388cf0bbd41119b8730dfc4b0b459", - "name": "CutFoodStep", - "versionInfo": "CutFoodStep.V1" - }, - "FryFoodStep": { - "$type": "Step", - "id": "c55af0425d864c4e97b6ae67bd715480", - "name": "FryFoodStep", - "versionInfo": "FryFoodStep.V1" - } - }, - "id": "cab89a17aeae4b9a97568967dbf1ea47", - "name": "FriedFishWithStatefulStepsProcess", - "versionInfo": "FriedFishProcess.v1" - }, - "AddBunsStep": { - "$type": "Step", - "id": "35d09b83dea24ddf8e0c24fbe6a3746c", - "name": "AddBunsStep", - "versionInfo": "v1" - }, - "AddSpecialSauceStep": { - "$type": "Step", - "id": "aa0d408976574afea94387e3da7ca111", - "name": "AddSpecialSauceStep", - "versionInfo": "v1" - }, - "ExternalFriedFishStep": { - "$type": "Step", - "id": "2eda38b8ee8745a4ab8b21f4fa01d173", - "name": "ExternalFriedFishStep", - "versionInfo": "v1" - } - }, - "id": "973b06f1-a522-4d2d-9e1c-ec45a07e275c", - "name": "FishSandwichWithStatefulStepsProcess", - "versionInfo": "FishSandwich.V1" -} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccess.json deleted file mode 100644 index d926c2db3cd1..000000000000 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccess.json +++ /dev/null @@ -1,28 +0,0 @@ -{ - "stepsState": { - "GatherFriedFishIngredientsWithStockStep": { - "$type": "Step", - "id": "77c2f967cd354e66a51828e9755d2f07", - "name": "GatherFriedFishIngredientsWithStockStep", - "versionInfo": "GatherFishIngredient.V2", - "state": { - "IngredientsStock": 4 - } - }, - "CutFoodStep": { - "$type": "Step", - "id": "9276d03e64c44a6792d5fd81bd0dc143", - "name": "CutFoodStep", - "versionInfo": "CutFoodStep.V1" - }, - "FryFoodStep": { - "$type": "Step", - "id": "af2a00be4fe2408181ab5654318ed56b", - "name": "FryFoodStep", - "versionInfo": "FryFoodStep.V1" - } - }, - "id": "2050a24b-3e9d-418a-8413-74cadf4f6b4c", - "name": "FriedFishWithStatefulStepsProcess", - "versionInfo": "FriedFishProcess.v1" -} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccessLowStock.json b/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccessLowStock.json deleted file mode 100644 index 10372bc65077..000000000000 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccessLowStock.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "$type": "Process", - "stepsState": { - "GatherFriedFishIngredientsWithStockStep": { - "$type": "Step", - "id": "92a4cda38c7248648b0aa7ffaaa57f21", - "name": "GatherFriedFishIngredientsWithStockStep", - "versionInfo": "GatherFishIngredient.V2", - "state": { - "IngredientsStock": 1 - } - }, - "CutFoodStep": { - "$type": "Step", - "id": "7ace89e38e1c48b0b3a700b40d160c68", - "name": "CutFoodStep", - "versionInfo": "CutFoodStep.V1" - }, - "FryFoodStep": { - "$type": "Step", - "id": "09bc39ba6d9745439c7c792b8dac0af7", - "name": "FryFoodStep", - "versionInfo": "FryFoodStep.V1" - } - }, - "id": "669c5850-9efc-4585-b3f0-9291a4471887", - "name": "FriedFishWithStatefulStepsProcess", - "versionInfo": "FriedFishProcess.v1" -} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccessNoStock.json b/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccessNoStock.json deleted file mode 100644 index 5c745ebe233f..000000000000 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/ProcessesStates/FriedFishProcessStateSuccessNoStock.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "$type": "Process", - "stepsState": { - "GatherFriedFishIngredientsWithStockStep": { - "$type": "Step", - "id": "92a4cda38c7248648b0aa7ffaaa57f21", - "name": "GatherFriedFishIngredientsWithStockStep", - "versionInfo": "GatherFishIngredient.V2", - "state": { - "IngredientsStock": 0 - } - }, - "CutFoodStep": { - "$type": "Step", - "id": "7ace89e38e1c48b0b3a700b40d160c68", - "name": "CutFoodStep", - "versionInfo": "CutFoodStep.V1" - }, - "FryFoodStep": { - "$type": "Step", - "id": "09bc39ba6d9745439c7c792b8dac0af7", - "name": "FryFoodStep", - "versionInfo": "FryFoodStep.V1" - } - }, - "id": "669c5850-9efc-4585-b3f0-9291a4471887", - "name": "FriedFishWithStatefulStepsProcess", - "versionInfo": "FriedFishProcess.v1" -} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId.FishSandwichWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId.FishSandwichWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..56ec811cc825 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId.FishSandwichWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,10 @@ +{ + "processName": "FishSandwichWithStatefulStepsProcess", + "processInstance": "myId", + "steps": { + "FriedFishWithStatefulStepsProcess": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa", + "AddBunsStep": "myId_8055d683-c7f0-46ab-8536-2badb6155d23", + "AddSpecialSauceStep": "myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe", + "ExternalFriedFishStep": "myId_6ab8c76d-0444-449a-8d23-97e44087ddc6" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa.FriedFishWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa.FriedFishWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..9399a4e05827 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa.FriedFishWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,9 @@ +{ + "processName": "FriedFishWithStatefulStepsProcess", + "processInstance": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa", + "steps": { + "GatherFriedFishIngredientsWithStockStep": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84", + "CutFoodStep": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566", + "FryFoodStep": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.ParentProcess.json new file mode 100644 index 000000000000..352f465f113b --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..fa8f333dc6c5 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.StepEdgesData.json @@ -0,0 +1,11 @@ +{ + "edgesData": { + "ChopFood": { + "foodActions": null + }, + "SliceFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.StepState.json new file mode 100644 index 000000000000..ba2e8e29435c --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566.CutFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_3bb5a954-86bb-47bb-ab43-578020c17566", + "name": "CutFoodStep", + "versionInfo": "CutFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.ParentProcess.json new file mode 100644 index 000000000000..352f465f113b --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..dee47bdd737f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "FryFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.StepState.json new file mode 100644 index 000000000000..1cf3b09c73dd --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9.FryFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_c0fb6338-a83b-4509-a14c-c40e7f112cc9", + "name": "FryFoodStep", + "versionInfo": "FryFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.ParentProcess.json new file mode 100644 index 000000000000..352f465f113b --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json new file mode 100644 index 000000000000..bbdfe707f014 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "GatherIngredients": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.StepState.json new file mode 100644 index 000000000000..2b859f2b99ab --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84.GatherFriedFishIngredientsWithStockStep.StepState.json @@ -0,0 +1,9 @@ +{ + "id": "myId_021dfcf8-6214-4eb9-a3a1-bc1da07418fa_f953864e-3cf5-4c9c-b66e-c662ebb88f84", + "name": "GatherFriedFishIngredientsWithStockStep", + "versionInfo": "GatherFishIngredient.V2", + "state": { + "ObjectType": "Step03.Steps.GatherIngredientsState, GettingStartedWithProcesses, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", + "Content": "{\u0022IngredientsStock\u0022:4}" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.StepEdgesData.json new file mode 100644 index 000000000000..4c45c96c6dac --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "AddSpecialSauce": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.StepState.json new file mode 100644 index 000000000000..5a80fb73f1e6 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe.AddSpecialSauceStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_23f1d31b-3ccf-488f-b3ce-517351f70bfe", + "name": "AddSpecialSauceStep", + "versionInfo": "v1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.StepEdgesData.json new file mode 100644 index 000000000000..fcb926001f80 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "EmitExternalEvent": { + "data": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.StepState.json new file mode 100644 index 000000000000..8da7e86f6b5c --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_6ab8c76d-0444-449a-8d23-97e44087ddc6.ExternalFriedFishStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_6ab8c76d-0444-449a-8d23-97e44087ddc6", + "name": "ExternalFriedFishStep", + "versionInfo": "v1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.StepEdgesData.json new file mode 100644 index 000000000000..958ebcdf12ec --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "AddBuns": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.StepState.json new file mode 100644 index 000000000000..a9fdc55e691d --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccess/myId_8055d683-c7f0-46ab-8536-2badb6155d23.AddBunsStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_8055d683-c7f0-46ab-8536-2badb6155d23", + "name": "AddBunsStep", + "versionInfo": "v1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId.FishSandwichWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId.FishSandwichWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..cc5dc3ba49ef --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId.FishSandwichWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,10 @@ +{ + "processName": "FishSandwichWithStatefulStepsProcess", + "processInstance": "myId", + "steps": { + "FriedFishWithStatefulStepsProcess": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b", + "AddBunsStep": "myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d", + "AddSpecialSauceStep": "myId_022844e1-f99d-48c9-b3ad-99124cd46aa0", + "ExternalFriedFishStep": "myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.StepEdgesData.json new file mode 100644 index 000000000000..4c45c96c6dac --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "AddSpecialSauce": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.StepState.json new file mode 100644 index 000000000000..a15f64a12b41 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_022844e1-f99d-48c9-b3ad-99124cd46aa0.AddSpecialSauceStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_022844e1-f99d-48c9-b3ad-99124cd46aa0", + "name": "AddSpecialSauceStep", + "versionInfo": "v1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.StepEdgesData.json new file mode 100644 index 000000000000..958ebcdf12ec --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "AddBuns": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.StepState.json new file mode 100644 index 000000000000..c795618fa5e6 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d.AddBunsStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_13f41383-fcc5-45c0-af76-88fb4a4d2e2d", + "name": "AddBunsStep", + "versionInfo": "v1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b.FriedFishWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b.FriedFishWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..0d1e4d1ba237 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b.FriedFishWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,9 @@ +{ + "processName": "FriedFishWithStatefulStepsProcess", + "processInstance": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b", + "steps": { + "GatherFriedFishIngredientsWithStockStep": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829", + "CutFoodStep": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f", + "FryFoodStep": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.ParentProcess.json new file mode 100644 index 000000000000..4305e9d3c3a7 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..fa8f333dc6c5 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.StepEdgesData.json @@ -0,0 +1,11 @@ +{ + "edgesData": { + "ChopFood": { + "foodActions": null + }, + "SliceFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.StepState.json new file mode 100644 index 000000000000..1fcc4e88c8d3 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f.CutFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_4b8faeff-a108-4427-a88a-3ebf7307973f", + "name": "CutFoodStep", + "versionInfo": "CutFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.ParentProcess.json new file mode 100644 index 000000000000..4305e9d3c3a7 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json new file mode 100644 index 000000000000..bbdfe707f014 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "GatherIngredients": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.StepState.json new file mode 100644 index 000000000000..3514d38e297a --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829.GatherFriedFishIngredientsWithStockStep.StepState.json @@ -0,0 +1,9 @@ +{ + "id": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_a1ef573e-5e92-4dbc-8d1d-8bc903014829", + "name": "GatherFriedFishIngredientsWithStockStep", + "versionInfo": "GatherFishIngredient.V2", + "state": { + "ObjectType": "Step03.Steps.GatherIngredientsState, GettingStartedWithProcesses, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", + "Content": "{\u0022IngredientsStock\u0022:1}" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.ParentProcess.json new file mode 100644 index 000000000000..4305e9d3c3a7 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..dee47bdd737f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "FryFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.StepState.json new file mode 100644 index 000000000000..e06e513e1ecc --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed.FryFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_a5ed1a9b-2534-43bd-baf3-99c5d1bbe15b_ef0e3c06-62fb-47eb-9212-072f9e2e27ed", + "name": "FryFoodStep", + "versionInfo": "FryFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.StepEdgesData.json new file mode 100644 index 000000000000..fcb926001f80 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "EmitExternalEvent": { + "data": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.StepState.json new file mode 100644 index 000000000000..624941f2996e --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FishSandwichSuccessLowStock/myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3.ExternalFriedFishStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_ae67a620-9ee2-4bc0-a7f0-ef43526643d3", + "name": "ExternalFriedFishStep", + "versionInfo": "v1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId.FriedFishWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId.FriedFishWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..b647f8d07789 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId.FriedFishWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,9 @@ +{ + "processName": "FriedFishWithStatefulStepsProcess", + "processInstance": "myId", + "steps": { + "GatherFriedFishIngredientsWithStockStep": "myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce", + "CutFoodStep": "myId_8fcf711d-ea39-4752-8222-41b534da697e", + "FryFoodStep": "myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json new file mode 100644 index 000000000000..bbdfe707f014 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "GatherIngredients": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.StepState.json new file mode 100644 index 000000000000..c7b3bfdab13f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce.GatherFriedFishIngredientsWithStockStep.StepState.json @@ -0,0 +1,9 @@ +{ + "id": "myId_21f95178-6c97-4ff7-a5a5-d89bbb47e7ce", + "name": "GatherFriedFishIngredientsWithStockStep", + "versionInfo": "GatherFishIngredient.V2", + "state": { + "ObjectType": "Step03.Steps.GatherIngredientsState, GettingStartedWithProcesses, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", + "Content": "{\u0022IngredientsStock\u0022:4}" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..dee47bdd737f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "FryFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.StepState.json new file mode 100644 index 000000000000..2c978fdf5563 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7.FryFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_4af3073f-89ba-4f96-9cf8-9cd3c0fbccf7", + "name": "FryFoodStep", + "versionInfo": "FryFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..fa8f333dc6c5 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.StepEdgesData.json @@ -0,0 +1,11 @@ +{ + "edgesData": { + "ChopFood": { + "foodActions": null + }, + "SliceFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.StepState.json new file mode 100644 index 000000000000..2918802f650d --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccess/myId_8fcf711d-ea39-4752-8222-41b534da697e.CutFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_8fcf711d-ea39-4752-8222-41b534da697e", + "name": "CutFoodStep", + "versionInfo": "CutFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId.FriedFishWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId.FriedFishWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..67c176b5fd9e --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId.FriedFishWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,9 @@ +{ + "processName": "FriedFishWithStatefulStepsProcess", + "processInstance": "myId", + "steps": { + "GatherFriedFishIngredientsWithStockStep": "myId_fbc551ab-1f31-47f4-92b1-0251909d86e2", + "CutFoodStep": "myId_c9e327ff-5673-4897-ae02-c4359c1d89de", + "FryFoodStep": "myId_db3f848e-1100-4aa8-b341-98dbae35a66c" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..fa8f333dc6c5 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.StepEdgesData.json @@ -0,0 +1,11 @@ +{ + "edgesData": { + "ChopFood": { + "foodActions": null + }, + "SliceFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.StepState.json new file mode 100644 index 000000000000..88003eb5dec6 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_c9e327ff-5673-4897-ae02-c4359c1d89de.CutFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_c9e327ff-5673-4897-ae02-c4359c1d89de", + "name": "CutFoodStep", + "versionInfo": "CutFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..dee47bdd737f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "FryFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.StepState.json new file mode 100644 index 000000000000..1b68cee6366f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_db3f848e-1100-4aa8-b341-98dbae35a66c.FryFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_db3f848e-1100-4aa8-b341-98dbae35a66c", + "name": "FryFoodStep", + "versionInfo": "FryFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json new file mode 100644 index 000000000000..bbdfe707f014 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "GatherIngredients": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.StepState.json new file mode 100644 index 000000000000..24778381135b --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessLowStock/myId_fbc551ab-1f31-47f4-92b1-0251909d86e2.GatherFriedFishIngredientsWithStockStep.StepState.json @@ -0,0 +1,9 @@ +{ + "id": "myId_fbc551ab-1f31-47f4-92b1-0251909d86e2", + "name": "GatherFriedFishIngredientsWithStockStep", + "versionInfo": "GatherFishIngredient.V2", + "state": { + "ObjectType": "Step03.Steps.GatherIngredientsState, GettingStartedWithProcesses, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", + "Content": "{\u0022IngredientsStock\u0022:1}" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId.FriedFishWithStatefulStepsProcess.ProcessState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId.FriedFishWithStatefulStepsProcess.ProcessState.json new file mode 100644 index 000000000000..6d03f5df51ce --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId.FriedFishWithStatefulStepsProcess.ProcessState.json @@ -0,0 +1,9 @@ +{ + "processName": "FriedFishWithStatefulStepsProcess", + "processInstance": "myId", + "steps": { + "GatherFriedFishIngredientsWithStockStep": "myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1", + "CutFoodStep": "myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9", + "FryFoodStep": "myId_0a64074a-ef1d-4222-a793-e22e9e189fad" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..dee47bdd737f --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "FryFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.StepState.json new file mode 100644 index 000000000000..d08bed8f61bb --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_0a64074a-ef1d-4222-a793-e22e9e189fad.FryFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_0a64074a-ef1d-4222-a793-e22e9e189fad", + "name": "FryFoodStep", + "versionInfo": "FryFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.StepEdgesData.json new file mode 100644 index 000000000000..fa8f333dc6c5 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.StepEdgesData.json @@ -0,0 +1,11 @@ +{ + "edgesData": { + "ChopFood": { + "foodActions": null + }, + "SliceFood": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.StepState.json new file mode 100644 index 000000000000..98678db2d157 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9.CutFoodStep.StepState.json @@ -0,0 +1,6 @@ +{ + "id": "myId_65e7d998-9d1c-4a5a-a5e4-2b5d6ffcd9d9", + "name": "CutFoodStep", + "versionInfo": "CutFoodStep.V1", + "state": null +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.ParentProcess.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.ParentProcess.json new file mode 100644 index 000000000000..386c61db9134 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.ParentProcess.json @@ -0,0 +1,3 @@ +{ + "parentId": "myId" +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json new file mode 100644 index 000000000000..bbdfe707f014 --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.StepEdgesData.json @@ -0,0 +1,8 @@ +{ + "edgesData": { + "GatherIngredients": { + "foodActions": null + } + }, + "isGroupEdge": false +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.StepState.json b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.StepState.json new file mode 100644 index 000000000000..6efd1e348ffc --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/States/FriedFishSuccessNoStock/myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1.GatherFriedFishIngredientsWithStockStep.StepState.json @@ -0,0 +1,9 @@ +{ + "id": "myId_91bd26f9-7894-46ae-8cb1-2bf55cb409f1", + "name": "GatherFriedFishIngredientsWithStockStep", + "versionInfo": "GatherFishIngredient.V2", + "state": { + "ObjectType": "Step03.Steps.GatherIngredientsState, GettingStartedWithProcesses, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", + "Content": "{\u0022IngredientsStock\u0022:0}" + } +} \ No newline at end of file diff --git a/dotnet/samples/GettingStartedWithProcesses/Step03/Step03a_FoodPreparation.cs b/dotnet/samples/GettingStartedWithProcesses/Step03/Step03a_FoodPreparation.cs index 99d2f2f4e122..a86073ede24e 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step03/Step03a_FoodPreparation.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step03/Step03a_FoodPreparation.cs @@ -1,8 +1,8 @@ // Copyright (c) Microsoft. All rights reserved. using Microsoft.SemanticKernel; -using Microsoft.SemanticKernel.Process.Models; using Microsoft.SemanticKernel.Process.Tools; +using SemanticKernel.Process.TestsShared.Services.Storage; using Step03.Processes; using Utilities; @@ -39,9 +39,9 @@ public async Task UsePrepareFishSandwichProcessAsync() var process = FishSandwichProcess.CreateProcess(); string mermaidGraph = process.ToMermaid(1); - Console.WriteLine($"=== Start - Mermaid Diagram for '{process.Name}' ==="); + Console.WriteLine($"=== Start - Mermaid Diagram for '{process.StepId}' ==="); Console.WriteLine(mermaidGraph); - Console.WriteLine($"=== End - Mermaid Diagram for '{process.Name}' ==="); + Console.WriteLine($"=== End - Mermaid Diagram for '{process.StepId}' ==="); await UsePrepareSpecificProductAsync(process, FishSandwichProcess.ProcessEvents.PrepareFishSandwich); } @@ -67,10 +67,10 @@ public async Task UsePrepareStatefulFriedFishProcessNoSharedStateAsync() Kernel kernel = CreateKernelWithChatCompletion(); // Assert - Console.WriteLine($"=== Start SK Process '{processBuilder.Name}' ==="); - await ExecuteProcessWithStateAsync(processBuilder.Build(), kernel, externalTriggerEvent, "Order 1"); - await ExecuteProcessWithStateAsync(processBuilder.Build(), kernel, externalTriggerEvent, "Order 2"); - Console.WriteLine($"=== End SK Process '{processBuilder.Name}' ==="); + Console.WriteLine($"=== Start SK Process '{processBuilder.StepId}' ==="); + await ExecuteProcessWithStateAsync(processBuilder.Build(), kernel, null, externalTriggerEvent, "Order 1"); + await ExecuteProcessWithStateAsync(processBuilder.Build(), kernel, null, externalTriggerEvent, "Order 2"); + Console.WriteLine($"=== End SK Process '{processBuilder.StepId}' ==="); } /// @@ -87,11 +87,11 @@ public async Task UsePrepareStatefulFriedFishProcessSharedStateAsync() Kernel kernel = CreateKernelWithChatCompletion(); KernelProcess kernelProcess = processBuilder.Build(); - Console.WriteLine($"=== Start SK Process '{processBuilder.Name}' ==="); - await ExecuteProcessWithStateAsync(kernelProcess, kernel, externalTriggerEvent, "Order 1"); - await ExecuteProcessWithStateAsync(kernelProcess, kernel, externalTriggerEvent, "Order 2"); - await ExecuteProcessWithStateAsync(kernelProcess, kernel, externalTriggerEvent, "Order 3"); - Console.WriteLine($"=== End SK Process '{processBuilder.Name}' ==="); + Console.WriteLine($"=== Start SK Process '{processBuilder.StepId}' ==="); + await ExecuteProcessWithStateAsync(kernelProcess, kernel, null, externalTriggerEvent, "Order 1"); + await ExecuteProcessWithStateAsync(kernelProcess, kernel, null, externalTriggerEvent, "Order 2"); + await ExecuteProcessWithStateAsync(kernelProcess, kernel, null, externalTriggerEvent, "Order 3"); + Console.WriteLine($"=== End SK Process '{processBuilder.StepId}' ==="); } [Fact] @@ -103,141 +103,115 @@ public async Task UsePrepareStatefulPotatoFriesProcessSharedStateAsync() Kernel kernel = CreateKernelWithChatCompletion(); KernelProcess kernelProcess = processBuilder.Build(); - Console.WriteLine($"=== Start SK Process '{processBuilder.Name}' ==="); - await ExecuteProcessWithStateAsync(kernelProcess, kernel, externalTriggerEvent, "Order 1"); - await ExecuteProcessWithStateAsync(kernelProcess, kernel, externalTriggerEvent, "Order 2"); - await ExecuteProcessWithStateAsync(kernelProcess, kernel, externalTriggerEvent, "Order 3"); - Console.WriteLine($"=== End SK Process '{processBuilder.Name}' ==="); + Console.WriteLine($"=== Start SK Process '{processBuilder.StepId}' ==="); + await ExecuteProcessWithStateAsync(kernelProcess, kernel, null, externalTriggerEvent, "Order 1"); + await ExecuteProcessWithStateAsync(kernelProcess, kernel, null, externalTriggerEvent, "Order 2"); + await ExecuteProcessWithStateAsync(kernelProcess, kernel, null, externalTriggerEvent, "Order 3"); + Console.WriteLine($"=== End SK Process '{processBuilder.StepId}' ==="); } - private async Task ExecuteProcessWithStateAsync(KernelProcess process, Kernel kernel, string externalTriggerEvent, string orderLabel = "Order 1") + private async Task ExecuteProcessWithStateAsync(KernelProcess process, Kernel kernel, IProcessStorageConnector? storageConnector, string externalTriggerEvent, string orderLabel = "Order 1", string? processId = null) { Console.WriteLine($"=== {orderLabel} ==="); var runningProcess = await process.StartAsync(kernel, new KernelProcessEvent() { Id = externalTriggerEvent, Data = new List() - }); + }, processId, storageConnector: storageConnector); return await runningProcess.GetStateAsync(); } - #region Running processes and saving Process State Metadata in a file locally - [Fact] - public async Task RunAndStoreStatefulFriedFishProcessStateAsync() - { - Kernel kernel = CreateKernelWithChatCompletion(); - ProcessBuilder builder = FriedFishProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess friedFishProcess = builder.Build(); - - var executedProcess = await ExecuteProcessWithStateAsync(friedFishProcess, kernel, externalTriggerEvent: FriedFishProcess.ProcessEvents.PrepareFriedFish); - var processState = executedProcess.ToProcessStateMetadata(); - DumpProcessStateMetadataLocally(processState, _statefulFriedFishProcessFilename); - } - - [Fact] - public async Task RunAndStoreStatefulFishSandwichProcessStateAsync() - { - Kernel kernel = CreateKernelWithChatCompletion(); - ProcessBuilder builder = FishSandwichProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess friedFishProcess = builder.Build(); - - var executedProcess = await ExecuteProcessWithStateAsync(friedFishProcess, kernel, externalTriggerEvent: FishSandwichProcess.ProcessEvents.PrepareFishSandwich); - var processState = executedProcess.ToProcessStateMetadata(); - DumpProcessStateMetadataLocally(processState, _statefulFishSandwichProcessFilename); - } - #endregion - #region Reading State from local file and apply to existing ProcessBuilder [Fact] public async Task RunStatefulFriedFishProcessFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFriedFishProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFriedFishProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FriedFishProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FriedFishProcess.ProcessEvents.PrepareFriedFish); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FriedFishProcess.ProcessEvents.PrepareFriedFish, processId: this._processId); } [Fact] public async Task RunStatefulFriedFishProcessWithLowStockFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFriedFishLowStockProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFriedFishLowStockProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FriedFishProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FriedFishProcess.ProcessEvents.PrepareFriedFish); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FriedFishProcess.ProcessEvents.PrepareFriedFish, processId: this._processId); } [Fact] public async Task RunStatefulFriedFishProcessWithNoStockFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFriedFishNoStockProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFriedFishNoStockProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FriedFishProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FriedFishProcess.ProcessEvents.PrepareFriedFish); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FriedFishProcess.ProcessEvents.PrepareFriedFish, processId: this._processId); } [Fact] public async Task RunStatefulFishSandwichProcessFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFishSandwichProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFishSandwichProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FishSandwichProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FishSandwichProcess.ProcessEvents.PrepareFishSandwich); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FishSandwichProcess.ProcessEvents.PrepareFishSandwich, processId: this._processId); } [Fact] public async Task RunStatefulFishSandwichProcessWithLowStockFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFishSandwichLowStockProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFishSandwichLowStockProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FishSandwichProcess.CreateProcessWithStatefulStepsV1(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FishSandwichProcess.ProcessEvents.PrepareFishSandwich); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FishSandwichProcess.ProcessEvents.PrepareFishSandwich, processId: this._processId); } #region Versioning compatibiily scenarios: Loading State generated with previous version of process [Fact] public async Task RunStatefulFriedFishV2ProcessWithLowStockV1StateFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFriedFishLowStockProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFriedFishLowStockProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FriedFishProcess.CreateProcessWithStatefulStepsV2(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FriedFishProcess.ProcessEvents.PrepareFriedFish); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FriedFishProcess.ProcessEvents.PrepareFriedFish, processId: this._processId); } [Fact] public async Task RunStatefulFishSandwichV2ProcessWithLowStockV1StateFromFileAsync() { - var processState = LoadProcessStateMetadata(this._statefulFishSandwichLowStockProcessFilename); - Assert.NotNull(processState); + var processStatePath = GetSampleStep03DirPath(this._statefulFishSandwichLowStockProcessFoldername); + var stateFileStorage = new JsonFileStorage(processStatePath); Kernel kernel = CreateKernelWithChatCompletion(); ProcessBuilder processBuilder = FishSandwichProcess.CreateProcessWithStatefulStepsV2(); - KernelProcess processFromFile = processBuilder.Build(processState); + KernelProcess processFromFile = processBuilder.Build(); - await ExecuteProcessWithStateAsync(processFromFile, kernel, externalTriggerEvent: FishSandwichProcess.ProcessEvents.PrepareFishSandwich); + await ExecuteProcessWithStateAsync(processFromFile, kernel, stateFileStorage, FishSandwichProcess.ProcessEvents.PrepareFishSandwich); } #endregion #endregion @@ -251,36 +225,26 @@ protected async Task UsePrepareSpecificProductAsync(ProcessBuilder processBuilde KernelProcess kernelProcess = processBuilder.Build(); // Assert - Console.WriteLine($"=== Start SK Process '{processBuilder.Name}' ==="); + Console.WriteLine($"=== Start SK Process '{processBuilder.StepId}' ==="); await using var runningProcess = await kernelProcess.StartAsync(kernel, new KernelProcessEvent() { Id = externalTriggerEvent, Data = new List() }); - Console.WriteLine($"=== End SK Process '{processBuilder.Name}' ==="); + Console.WriteLine($"=== End SK Process '{processBuilder.StepId}' ==="); } // Step03a Utils for saving and loading SK Processes from/to repository - private readonly string _step03RelativePath = Path.Combine("Step03", "ProcessesStates"); - private readonly string _statefulFriedFishProcessFilename = "FriedFishProcessStateSuccess.json"; - private readonly string _statefulFriedFishLowStockProcessFilename = "FriedFishProcessStateSuccessLowStock.json"; - private readonly string _statefulFriedFishNoStockProcessFilename = "FriedFishProcessStateSuccessNoStock.json"; - private readonly string _statefulFishSandwichProcessFilename = "FishSandwichStateProcessSuccess.json"; - private readonly string _statefulFishSandwichLowStockProcessFilename = "FishSandwichStateProcessSuccessLowStock.json"; - - private void DumpProcessStateMetadataLocally(KernelProcessStateMetadata processStateInfo, string jsonFilename) - { - var sampleRelativePath = GetSampleStep03Filepath(jsonFilename); - ProcessStateMetadataUtilities.DumpProcessStateMetadataLocally(processStateInfo, sampleRelativePath); - } - - private KernelProcessStateMetadata? LoadProcessStateMetadata(string jsonFilename) - { - var sampleRelativePath = GetSampleStep03Filepath(jsonFilename); - return ProcessStateMetadataUtilities.LoadProcessStateMetadata(sampleRelativePath); - } - - private string GetSampleStep03Filepath(string jsonFilename) - { - return Path.Combine(this._step03RelativePath, jsonFilename); + private readonly string _processId = "myId"; + private readonly string _step03RelativePath = Path.Combine("Step03", "States"); + private readonly string _statefulFriedFishProcessFoldername = "FriedFishSuccess"; + private readonly string _statefulFriedFishLowStockProcessFoldername = "FriedFishSuccessLowStock"; + private readonly string _statefulFriedFishNoStockProcessFoldername = "FriedFishSuccessNoStock"; + private readonly string _statefulFishSandwichProcessFoldername = "FishSandwichSuccess"; + private readonly string _statefulFishSandwichLowStockProcessFoldername = "FishSandwichSuccessLowStock"; + + private string GetSampleStep03DirPath(string dir) + { + var relativeDir = Path.Combine(this._step03RelativePath, dir); + return FileStorageUtilities.GetRepositoryProcessStateFilepath(relativeDir, checkFilepathExists: true); } } diff --git a/dotnet/samples/GettingStartedWithProcesses/Step04/Step04_AgentOrchestration.cs b/dotnet/samples/GettingStartedWithProcesses/Step04/Step04_AgentOrchestration.cs index 3bcf8758956a..e4c0bb1d3ddf 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step04/Step04_AgentOrchestration.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step04/Step04_AgentOrchestration.cs @@ -74,7 +74,7 @@ await process.StartAsync( // Cleaning up created agents var processState = await localProcess.GetStateAsync(); - var agentState = (KernelProcessStepState)processState.Steps.Where(step => step.State.Id == "Student").FirstOrDefault()!.State; + var agentState = (KernelProcessStepState)processState.Steps.Where(step => step.State.StepId == "Student").FirstOrDefault()!.State; var agentId = agentState?.State?.AgentId; if (agentId != null) { @@ -168,7 +168,7 @@ private KernelProcess SetupSingleAgentProcess(string processName // Pass user input to primary agent userInputStep .OnEvent(CommonEvents.UserInputReceived) - .SendEventTo(new ProcessFunctionTargetBuilder(agentStep, parameterName: "message")) + .SendEventTo(new ProcessFunctionTargetBuilder(agentStep)) .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderUserText)); agentStep @@ -178,7 +178,7 @@ private KernelProcess SetupSingleAgentProcess(string processName agentStep .OnFunctionError() - .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderError, "error")) + .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderError)) .StopProcess(); return process.Build(); @@ -215,7 +215,7 @@ private KernelProcess SetupAgentProcess(string processName) wher userInputStep .OnEvent(CommonEvents.UserInputReceived) .SendEventTo(new ProcessFunctionTargetBuilder(managerAgentStep, ManagerAgentStep.ProcessStepFunctions.InvokeAgent)) - .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderUserText, parameterName: "message")); + .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderUserText)); // Process completed userInputStep @@ -226,7 +226,7 @@ private KernelProcess SetupAgentProcess(string processName) wher // Render response from primary agent managerAgentStep .OnEvent(AgentOrchestrationEvents.AgentResponse) - .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderMessage, parameterName: "message")); + .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderMessage)); // Request is complete managerAgentStep @@ -247,17 +247,17 @@ private KernelProcess SetupAgentProcess(string processName) wher // Provide input to inner agents managerAgentStep .OnEvent(AgentOrchestrationEvents.GroupInput) - .SendEventTo(new ProcessFunctionTargetBuilder(agentGroupStep, parameterName: "input")); + .SendEventTo(new ProcessFunctionTargetBuilder(agentGroupStep)); // Render response from inner chat (for visibility) agentGroupStep .OnEvent(AgentOrchestrationEvents.GroupMessage) - .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderInnerMessage, parameterName: "message")); + .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderInnerMessage)); // Provide inner response to primary agent agentGroupStep .OnEvent(AgentOrchestrationEvents.GroupCompleted) - .SendEventTo(new ProcessFunctionTargetBuilder(managerAgentStep, ManagerAgentStep.ProcessStepFunctions.ReceiveResponse, parameterName: "response")); + .SendEventTo(new ProcessFunctionTargetBuilder(managerAgentStep, ManagerAgentStep.ProcessStepFunctions.ReceiveResponse)); KernelProcess kernelProcess = process.Build(); @@ -269,7 +269,7 @@ void AttachErrorStep(ProcessStepBuilder step, params string[] functionNames) { step .OnFunctionError(functionName) - .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderError, "error")) + .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.ProcessStepFunctions.RenderError)) .StopProcess(); } } diff --git a/dotnet/samples/GettingStartedWithProcesses/Step06/Step06_FoundryAgentProcess.cs b/dotnet/samples/GettingStartedWithProcesses/Step06/Step06_FoundryAgentProcess.cs index 7465fe5610c9..0592d6810720 100644 --- a/dotnet/samples/GettingStartedWithProcesses/Step06/Step06_FoundryAgentProcess.cs +++ b/dotnet/samples/GettingStartedWithProcesses/Step06/Step06_FoundryAgentProcess.cs @@ -10,6 +10,7 @@ using OpenAI; namespace Step06; + public class Step06_FoundryAgentProcess : BaseTest { public Step06_FoundryAgentProcess(ITestOutputHelper output) : base(output, redirectSystemConsoleOutput: true) diff --git a/dotnet/samples/GettingStartedWithProcesses/Utilities/FileStorageUtilities.cs b/dotnet/samples/GettingStartedWithProcesses/Utilities/FileStorageUtilities.cs new file mode 100644 index 000000000000..768da6b3290c --- /dev/null +++ b/dotnet/samples/GettingStartedWithProcesses/Utilities/FileStorageUtilities.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; + +namespace Utilities; +public static class FileStorageUtilities +{ + // Path used for storing json processes samples in repository + private static readonly string s_currentSourceDir = Path.Combine( + Directory.GetCurrentDirectory(), "..", "..", ".."); + + public static string GetRepositoryProcessStateFilepath(string relativePath, bool checkFilepathExists = false) + { + string fullPath = Path.Combine(s_currentSourceDir, relativePath); + if (checkFilepathExists && !Directory.Exists(fullPath)) + { + throw new KernelException($"Path {fullPath} does not exist"); + } + + return fullPath; + } +} diff --git a/dotnet/samples/GettingStartedWithProcesses/Utilities/ProcessStateMetadataUtilities.cs b/dotnet/samples/GettingStartedWithProcesses/Utilities/ProcessStateMetadataUtilities.cs deleted file mode 100644 index 9d80f650a238..000000000000 --- a/dotnet/samples/GettingStartedWithProcesses/Utilities/ProcessStateMetadataUtilities.cs +++ /dev/null @@ -1,70 +0,0 @@ -// Copyright (c) Microsoft. All rights reserved. - -using System.Text.Json; -using Microsoft.SemanticKernel; -using Microsoft.SemanticKernel.Process.Models; - -namespace Utilities; -public static class ProcessStateMetadataUtilities -{ - // Path used for storing json processes samples in repository - private static readonly string s_currentSourceDir = Path.Combine( - Directory.GetCurrentDirectory(), "..", "..", ".."); - - private static readonly JsonSerializerOptions s_jsonOptions = new() - { - WriteIndented = true, - DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull - }; - - public static void DumpProcessStateMetadataLocally(KernelProcessStateMetadata processStateInfo, string jsonFilename) - { - var filepath = GetRepositoryProcessStateFilepath(jsonFilename); - StoreProcessStateLocally(processStateInfo, filepath); - } - - public static KernelProcessStateMetadata? LoadProcessStateMetadata(string jsonRelativePath) - { - var filepath = GetRepositoryProcessStateFilepath(jsonRelativePath, checkFilepathExists: true); - - Console.WriteLine($"Loading ProcessStateMetadata from:\n'{Path.GetFullPath(filepath)}'"); - - using StreamReader reader = new(filepath); - var content = reader.ReadToEnd(); - return JsonSerializer.Deserialize(content, s_jsonOptions); - } - - private static string GetRepositoryProcessStateFilepath(string jsonRelativePath, bool checkFilepathExists = false) - { - string filepath = Path.Combine(s_currentSourceDir, jsonRelativePath); - if (checkFilepathExists && !File.Exists(filepath)) - { - throw new KernelException($"Filepath {filepath} does not exist"); - } - - return filepath; - } - - /// - /// Function that stores the definition of the SK Process State`.
- /// - /// Process State to be stored - /// Filepath to store definition of process in json format - private static void StoreProcessStateLocally(KernelProcessStateMetadata processStateInfo, string fullFilepath) - { - if (!(Path.GetDirectoryName(fullFilepath) is string directory && Directory.Exists(directory))) - { - throw new KernelException($"Directory for path '{fullFilepath}' does not exist, could not save process {processStateInfo.Name}"); - } - - if (!(Path.GetExtension(fullFilepath) is string extension && !string.IsNullOrEmpty(extension) && extension == ".json")) - { - throw new KernelException($"Filepath for process {processStateInfo.Name} does not have .json extension"); - } - - string content = JsonSerializer.Serialize(processStateInfo, s_jsonOptions); - Console.WriteLine($"Process State: \n{content}"); - Console.WriteLine($"Saving Process State Locally: \n{Path.GetFullPath(fullFilepath)}"); - File.WriteAllText(fullFilepath, content); - } -} diff --git a/dotnet/src/Experimental/Process.Abstractions/IKernelProcessUserStateStore.cs b/dotnet/src/Experimental/Process.Abstractions/IKernelProcessUserStateStore.cs new file mode 100644 index 000000000000..05f46455ca5a --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/IKernelProcessUserStateStore.cs @@ -0,0 +1,28 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Threading.Tasks; + +namespace Microsoft.SemanticKernel; + +/// +/// interface for a store that manages user state for kernel processes. +/// +public interface IKernelProcessUserStateStore +{ + /// + /// Defines the key used to store user state in the store. + /// + /// + /// + /// + Task GetUserStateAsync(string key) where T : class; + + /// + /// Sets the user state in the store. + /// + /// + /// + /// + /// + Task SetUserStateAsync(string key, T state) where T : class; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/IProcessStepStorageOperations.cs b/dotnet/src/Experimental/Process.Abstractions/IProcessStepStorageOperations.cs new file mode 100644 index 000000000000..3ceec92fc1ab --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/IProcessStepStorageOperations.cs @@ -0,0 +1,64 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Threading.Tasks; +using Microsoft.SemanticKernel.Process.Models.Storage; + +namespace Microsoft.SemanticKernel; + +/// +/// Defines operations for managing the storage of process step information, state, and events. +/// +public interface IProcessStepStorageOperations +{ + // For now step data is fetched by parent process only. + // Task FetchStepDataAsync(KernelProcessStepInfo step); + + /// + /// Retrieves detailed information about a specific process step: parentId, version, etc. + /// + /// The step for which information is to be retrieved. This parameter cannot be null. + /// A task that represents the asynchronous operation. The task result contains a + /// object with the step details, or if the step information is not available. + Task GetStepInfoAsync(KernelProcessStepInfo stepInfo); + + /// + /// Saves detailed information about a specific process step, such as parentId, version, etc. + /// + /// + /// + Task SaveStepInfoAsync(KernelProcessStepInfo stepInfo); + + /// + /// Retrieves the current state of a process step. + /// + /// + /// A task that represents the asynchronous operation. The task result contains the current state of the specified + /// step, or if the step does not exist. + Task GetStepStateAsync(KernelProcessStepInfo stepInfo); + + /// + /// Saves the current state of a process step. + /// + /// + /// + Task SaveStepStateAsync(KernelProcessStepInfo stepInfo); + + /// + /// Retrieves the events associated with a specific process step. + /// + /// + /// + Task GetStepEventsAsync(KernelProcessStepInfo stepInfo); + + /// + /// Saves the events associated with a specific process step. + /// + /// + /// + /// + Task SaveStepEventsAsync(KernelProcessStepInfo stepInfo, Dictionary>? edgeGroups = null); + // For now step data can be saved to storage only by parent process only. + // This is to only save data to storage at the end of the process super step execution. + //Task SaveStepDataToStorageAsync(KernelProcessStepInfo step); +} diff --git a/dotnet/src/Experimental/Process.Abstractions/IProcessStorageConnector.cs b/dotnet/src/Experimental/Process.Abstractions/IProcessStorageConnector.cs new file mode 100644 index 000000000000..4ec030ccc845 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/IProcessStorageConnector.cs @@ -0,0 +1,48 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Threading.Tasks; + +namespace Microsoft.SemanticKernel; + +/// +/// An interface that provides a channel interacting with custom storage +/// +public interface IProcessStorageConnector +{ + /// + /// Logic executed when creating a new storage connection + /// + /// A + abstract ValueTask OpenConnectionAsync(); + + /// + /// Logic executed when closing opened storage connection + /// + /// A + abstract ValueTask CloseConnectionAsync(); + + /// + /// Get specific entry type by id + /// + /// class that defines the entry type to be extracted from storage + /// id of entry used storage + /// + abstract Task GetEntryAsync(string id) where TEntry : class; + + /// + /// Save specific entry type with assigned id + /// + /// + /// id of entry used storage + /// type of entry used in storage + /// data to be stored in storage + /// + abstract Task SaveEntryAsync(string id, string type, TEntry entry) where TEntry : class; + + /// + /// Delete specific entry from storage + /// + /// id of entry used storage + /// + abstract Task DeleteEntryAsync(string id); +} diff --git a/dotnet/src/Experimental/Process.Abstractions/IProcessStorageOperations.cs b/dotnet/src/Experimental/Process.Abstractions/IProcessStorageOperations.cs new file mode 100644 index 000000000000..32c3efd6455e --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/IProcessStorageOperations.cs @@ -0,0 +1,92 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Threading.Tasks; +using Microsoft.SemanticKernel.Process.Models.Storage; + +namespace Microsoft.SemanticKernel; + +internal interface IProcessStorageOperations +{ + /// + /// Initializes the storage connection to be used by the process. + /// + /// + Task InitializeAsync(); + /// + /// Closes storage connection and cleans up resources. + /// + /// + Task CloseAsync(); + /// + /// Fetches from storage the process data for a specific process. + /// + /// + /// + Task FetchProcessDataAsync(KernelProcess process); + /// + /// Get the process information already retrieved from storage, including parentId, version, mapping of steps and running ids. + /// + /// + /// + Task GetProcessInfoAsync(KernelProcess process); + /// + /// Saves the process information to storage, including parentId, version, mapping of steps and running ids. + /// + /// + /// + Task SaveProcessInfoAsync(KernelProcess process); + + /// + /// Retrieves a list of external events associated with the specified kernel process. + /// + /// + /// + Task?> GetProcessExternalEventsAsync(KernelProcess process); + + /// + /// Save process events to storage, including pending external events. + /// + /// + /// + /// + Task SaveProcessEventsAsync(KernelProcess process, List? pendingExternalEvents = null); + + /// + /// Retrieve process shared variables + /// + /// + /// + Task?> GetProcessStateVariablesAsync(KernelProcess process); + + /// + /// Save process state related components + /// + /// + /// + /// + Task SaveProcessStateAsync(KernelProcess process, Dictionary sharedVariables); + + /// + /// Saves all process related data to storage, including process info, events, and step data. + /// + /// + /// + Task SaveProcessDataToStorageAsync(KernelProcess process); + + // Step related operations to be applied to process children steps only + + /// + /// Fetches from storage the step data for a specific process step. + /// + /// + /// + Task FetchStepDataAsync(KernelProcessStepInfo stepInfo); + + /// + /// Saves the step data to storage. + /// + /// + /// + Task SaveStepDataToStorageAsync(KernelProcessStepInfo stepInfo); +} diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcess.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcess.cs index d35c29ad6a78..355765de5c32 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcess.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcess.cs @@ -15,7 +15,7 @@ public sealed record KernelProcess : KernelProcessStepInfo /// /// The collection of Steps in the Process. /// - public IList Steps { get; } + public IList Steps { get; init; } /// /// The collection of Threads in the Process. @@ -47,7 +47,7 @@ public KernelProcess(KernelProcessState state, IList step : base(typeof(KernelProcess), state, edges ?? []) { Verify.NotNull(steps); - Verify.NotNullOrWhiteSpace(state.Name); + Verify.NotNullOrWhiteSpace(state.StepId); this.Steps = [.. steps]; } diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessContext.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessContext.cs index 12fbd9ed8b23..9c1cd2932af5 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessContext.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessContext.cs @@ -1,5 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; using System.Threading.Tasks; namespace Microsoft.SemanticKernel.Process; @@ -28,6 +29,12 @@ public abstract class KernelProcessContext /// A where T is public abstract Task GetStateAsync(); + /// + /// Gets a snapshot of the step states. + /// + /// + public abstract Task> GetStepStatesAsync(); + /// /// Gets the instance of used for external messages /// diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessMap.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessMap.cs index f171b9527c77..58f009ba67fa 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessMap.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessMap.cs @@ -11,7 +11,7 @@ public sealed record KernelProcessMap : KernelProcessStepInfo /// /// The map operation. /// - public KernelProcessStepInfo Operation { get; } + public KernelProcessStepInfo Operation { get; init; } /// /// Creates a new instance of the class. @@ -23,8 +23,8 @@ public KernelProcessMap(KernelProcessMapState state, KernelProcessStepInfo opera : base(typeof(KernelProcessMap), state, edges) { Verify.NotNull(operation, nameof(operation)); - Verify.NotNullOrWhiteSpace(state.Name, $"{nameof(state)}.{nameof(KernelProcessMapState.Name)}"); - Verify.NotNullOrWhiteSpace(state.Id, $"{nameof(state)}.{nameof(KernelProcessMapState.Id)}"); + Verify.NotNullOrWhiteSpace(state.StepId, $"{nameof(state)}.{nameof(KernelProcessMapState.StepId)}"); + Verify.NotNullOrWhiteSpace(state.RunId, $"{nameof(state)}.{nameof(KernelProcessMapState.RunId)}"); this.Operation = operation; } diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessProxy.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessProxy.cs index de0cac9b221b..ec9ba3c9aabd 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessProxy.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessProxy.cs @@ -23,7 +23,7 @@ public sealed record KernelProcessProxy : KernelProcessStepInfo public KernelProcessProxy(KernelProcessStepState state, Dictionary> edges) : base(typeof(KernelProxyStep), state, edges) { - Verify.NotNullOrWhiteSpace(state.Name, $"{nameof(state)}.{nameof(KernelProcessStepState.Name)}"); - Verify.NotNullOrWhiteSpace(state.Id, $"{nameof(state)}.{nameof(KernelProcessStepState.Id)}"); + Verify.NotNullOrWhiteSpace(state.StepId, $"{nameof(state)}.{nameof(KernelProcessStepState.StepId)}"); + Verify.NotNullOrWhiteSpace(state.RunId, $"{nameof(state)}.{nameof(KernelProcessStepState.RunId)}"); } } diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStep.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStep.cs index c3162340bb35..81d434c92c84 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStep.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStep.cs @@ -9,6 +9,11 @@ namespace Microsoft.SemanticKernel; /// public class KernelProcessStep { + /// + /// Name of the step given by the StepBuilder id. + /// + public string? StepName { get; init; } + /// public virtual ValueTask ActivateAsync(KernelProcessStepState state) { diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepContext.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepContext.cs index e652e0adb367..1e55df778c34 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepContext.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepContext.cs @@ -10,14 +10,17 @@ namespace Microsoft.SemanticKernel; public sealed class KernelProcessStepContext { private readonly IKernelProcessMessageChannel _stepMessageChannel; + private readonly IKernelProcessUserStateStore? _userStateStore; /// /// Initializes a new instance of the class. /// /// An instance of . - public KernelProcessStepContext(IKernelProcessMessageChannel channel) + /// An instance of + public KernelProcessStepContext(IKernelProcessMessageChannel channel, IKernelProcessUserStateStore? userStateStore = null) { this._stepMessageChannel = channel; + this._userStateStore = userStateStore; } /// @@ -52,4 +55,27 @@ public ValueTask EmitEventAsync( Visibility = visibility }); } + + /// + /// Gets the user state of the process. + /// + /// The key to identify the user state. + /// + /// + public Task GetUserStateAsync(string key) where T : class + { + return this._userStateStore?.GetUserStateAsync(key) ?? Task.FromResult(null!); + } + + /// + /// Sets the user state of the process. + /// + /// + /// + /// + /// + public Task SetUserStateAsync(string key, T state) where T : class + { + return this._userStateStore?.SetUserStateAsync(key, state) ?? Task.CompletedTask; + } } diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepInfo.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepInfo.cs index 92f5016b2e46..317fd1741ff5 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepInfo.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepInfo.cs @@ -31,6 +31,15 @@ public KernelProcessStepState State } } + /// + public string? RunId => this.State.RunId; + + /// + public string? StepId => this.State.StepId; + + /// + public string? ParentId => this.State.ParentId; + /// /// The semantic description of the Step. This is intended to be human and AI readable and is not required to be unique. /// @@ -39,7 +48,7 @@ public KernelProcessStepState State /// /// A read-only dictionary of output edges from the Step. /// - public IReadOnlyDictionary> Edges { get; } + public IReadOnlyDictionary> Edges { get; init; } /// /// A dictionary of input mappings for the grouped edges. diff --git a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepState.cs b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepState.cs index e4e2b816cb8c..cdce206635eb 100644 --- a/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepState.cs +++ b/dotnet/src/Experimental/Process.Abstractions/KernelProcessStepState.cs @@ -4,6 +4,7 @@ using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.Serialization; +using System.Text.Json.Serialization; namespace Microsoft.SemanticKernel; @@ -40,34 +41,44 @@ internal static void RegisterDerivedType(Type derivedType) /// This may be null until a process containing this step has been invoked. /// [DataMember] - public string? Id { get; init; } + [JsonPropertyName("runId")] + public string? RunId { get; set; } + + /// + /// Gets or sets the identifier of the step parent. + /// + [DataMember] + [JsonPropertyName("parentId")] + public string? ParentId { get; set; } /// /// The name of the Step. This is intended to be human readable and is not required to be unique. If /// not provided, the name will be derived from the steps .NET type. /// [DataMember] - public string Name { get; init; } + [JsonPropertyName("stepId")] + public string StepId { get; init; } /// /// Version of the state /// [DataMember] + [JsonPropertyName("version")] public string Version { get; init; } /// /// Initializes a new instance of the class. /// - /// The name of the associated + /// The name of the associated /// version id of the process step state - /// The Id of the associated - public KernelProcessStepState(string name, string version, string? id = null) + /// The Id of the associated + public KernelProcessStepState(string stepId, string version, string? runId = null) { - Verify.NotNullOrWhiteSpace(name, nameof(name)); + Verify.NotNullOrWhiteSpace(stepId, nameof(stepId)); Verify.NotNullOrWhiteSpace(version, nameof(version)); - this.Id = id; - this.Name = name; + this.RunId = runId; + this.StepId = stepId; this.Version = version; } } @@ -83,21 +94,31 @@ public KernelProcessStepState(string name, string version, string? id = null) /// The user-defined state object associated with the Step. /// [DataMember] + [JsonPropertyName("state")] public TState? State { get; init; } /// /// Initializes a new instance of the class. /// - /// The name of the associated + /// The name of the associated /// version id of the process step state - /// The Id of the associated - public KernelProcessStepState(string name, string version, string? id = null) - : base(name, version, id) + /// The Id of the associated + public KernelProcessStepState(string stepId, string version, string? runId = null) + : base(stepId, version, runId) { - Verify.NotNullOrWhiteSpace(name); + Verify.NotNullOrWhiteSpace(stepId); - this.Id = id; - this.Name = name; + this.RunId = runId; + this.StepId = stepId; this.Version = version; } + + /// + /// Initializes a new instance of the class. + /// + /// + public KernelProcessStepState(KernelProcessStepState stepState) + : base(stepState.StepId, stepState.Version, stepState.RunId) + { + } } diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageEntryBase.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageEntryBase.cs new file mode 100644 index 000000000000..02514fe198b5 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageEntryBase.cs @@ -0,0 +1,17 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Base class for storage entries. +/// +public abstract record StorageEntryBase +{ + /// + /// Unique identifier of the storage entry. + /// + [JsonPropertyName("instanceId")] + public string InstanceId { get; set; } = string.Empty; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessData.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessData.cs new file mode 100644 index 000000000000..5c30d216a29c --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessData.cs @@ -0,0 +1,32 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +// it seems all properties needed are already in KernelProcessStepStateMetadata +// using new class for now in case there some extra props needed while +// plumbing +/// +/// Data class for the parent of a step. +/// +public record StorageProcessData : StorageEntryBase +{ + /// + /// Process runtime details like id, parent id, step id mapping, etc. + /// + [JsonPropertyName("processInfo")] + public StorageProcessInfo ProcessInfo { get; set; } = new(); + + /// + /// Process runtime unprocessed events + /// + [JsonPropertyName("processEvents")] + public StorageProcessEvents ProcessEvents { get; set; } = new(); + + /// + /// Process state/variables related data + /// + [JsonPropertyName("processState")] + public StorageProcessState ProcessState { get; set; } = new(); +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessEvents.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessEvents.cs new file mode 100644 index 000000000000..a4f4846a0b85 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessEvents.cs @@ -0,0 +1,26 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of a process state. +/// +public record StorageProcessEvents +{ + /// + /// Gets or sets the list of external pending messages associated with the process. + /// + [JsonPropertyName("externalPendingMessages")] + public List ExternalPendingMessages { get; set; } = []; + + /* TODO: + * Hypothetically step edgeGroup pending messages logic could be moved to the process and save it here + * All "pending messages" that cannot be processed by a step yet (waiting on some condition) + * could be moved to the process layer instead. + */ + //[JsonPropertyName("internalPendingMessages")] + //public List InternalProcessEvents { get; set; } = []; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessExtensions.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessExtensions.cs new file mode 100644 index 000000000000..3338107f0675 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessExtensions.cs @@ -0,0 +1,67 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Linq; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; +/// +/// Extension methods for converting between StorageProcessState and KernelProcess. +/// +public static class StorageProcessExtension +{ + /// + /// Converts a to a . + /// + /// instance of + /// + public static StorageProcessInfo ToKernelStorageProcessInfo(this KernelProcess kernelProcess) + { + return new StorageProcessInfo + { + ProcessName = kernelProcess.StepId ?? string.Empty, + InstanceId = kernelProcess.RunId ?? string.Empty, + Steps = kernelProcess.Steps.ToList().ToDictionary(step => step.State.StepId, step => step.State.RunId ?? string.Empty) ?? [], + ParentId = kernelProcess.ParentId, + }; + } + + /// + /// Converts a to a . + /// + /// list of ending external events to be processed + /// + public static StorageProcessEvents ToKernelStorageProcessEvents(List? pendingExternalEvents = null) + { + return new StorageProcessEvents + { + ExternalPendingMessages = pendingExternalEvents ?? new List(), + }; + } + + /// + /// Converts a to a dictionary of shared variables for the kernel process. + /// + /// + /// + public static Dictionary ToKernelProcessSharedVariables(this StorageProcessState storageProcessState) + { + return storageProcessState.SharedVariables.ToDictionary( + kvp => kvp.Key, + kvp => kvp.Value?.ToObject()); + } + + /// + /// Converts a to a . + /// + /// + /// + public static StorageProcessState ToKernelStorageProcessState(Dictionary? processSharedVariables = null) + { + return new StorageProcessState + { + SharedVariables = processSharedVariables?.ToDictionary( + kvp => kvp.Key, + kvp => KernelProcessEventData.FromObject(kvp.Value)) ?? [] + }; + } +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessInfo.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessInfo.cs new file mode 100644 index 000000000000..13d6672703e0 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessInfo.cs @@ -0,0 +1,32 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of a process state. +/// +public record StorageProcessInfo : StorageEntryBase +{ + /// + /// Name of the process builder used to create the process instance + /// + [JsonPropertyName("processName")] + public string ProcessName { get; set; } = string.Empty; + + /// + /// Id of the parent process, if null the process is a root process. + /// + [JsonPropertyName("parentId")] + public string? ParentId { get; set; } = null; + + /// + /// Map containing Step Names and their respective step instance + /// + [JsonPropertyName("steps")] + public Dictionary Steps { get; set; } = []; + + // TODO: Add running state here: RUNNING, COMPLETED (EndStep was reached), IDLE (it ran and no more events are in queue to be processed) +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessState.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessState.cs new file mode 100644 index 000000000000..a69d2b0ccd65 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageProcessState.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of a process state. +/// +public record StorageProcessState +{ + // Properties here should match properties used by LocalUserStateStore + + /// + /// Collection of shared variables used by the process and process steps. + /// Saving values as KernelProcessEventData to allow serialization and deserialization of custom objects. + /// + [JsonPropertyName("sharedVariables")] + public Dictionary SharedVariables { get; init; } = []; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepData.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepData.cs new file mode 100644 index 000000000000..60367347e0a0 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepData.cs @@ -0,0 +1,29 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Data class for the parent of a step. +/// +public record StorageStepData : StorageEntryBase +{ + /// + /// Process runtime details like id, parent id, step id mapping, etc. + /// + [JsonPropertyName("stepInfo")] + public StorageStepInfo StepInfo { get; set; } + + /// + /// Process runtime unprocessed events + /// + [JsonPropertyName("stepEvents")] + public StorageStepEvents? StepEvents { get; set; } = null; + + /// + /// Step state if any. + /// + [JsonPropertyName("stepState")] + public StorageStepState? StepState { get; set; } = null; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepEdgesData.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepEdgesData.cs new file mode 100644 index 000000000000..7a4aae72b81f --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepEdgesData.cs @@ -0,0 +1,29 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Runtime.Serialization; +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of step edges data. +/// +public record StorageStepEdgesData +{ + // TODO: potentially also add versioning/snapshot info to allow "going back in time" + + /// + /// Data received by step edges + /// + [DataMember] + [JsonPropertyName("edgesData")] + public Dictionary> EdgesData { get; set; } = []; + + /// + /// Indicates if the edge is a group edge + /// + [DataMember] + [JsonPropertyName("isGroupEdge")] + public bool IsGroupEdge { get; set; } = false; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepEvents.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepEvents.cs new file mode 100644 index 000000000000..d634ac206f6e --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepEvents.cs @@ -0,0 +1,20 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of step edges data. +/// +public record StorageStepEvents +{ + /// + /// Data received by step edges, used when step function has multiple parameters + /// + [JsonPropertyName("edgeGroupEvents")] + public Dictionary>? EdgesData { get; set; } = null; + + //[JsonPropertyName("lastEventReceived")] +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepExtensions.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepExtensions.cs new file mode 100644 index 000000000000..af9f5aaacd7f --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepExtensions.cs @@ -0,0 +1,93 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using Microsoft.SemanticKernel.Process.Internal; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; +/// +/// Extension methods for converting between StorageStepState and KernelProcessStepStateMetadata. +/// +public static class StorageStepExtensions +{ + /// + /// Converts a KernelProcessStepInfo to a StorageStepInfo. + /// + /// + /// + public static StorageStepInfo ToStorageStepInfo(this KernelProcessStepInfo step) + { + return new StorageStepInfo + { + StepName = step.StepId!, + InstanceId = step.RunId!, + ParentId = step.ParentId!, + // There should be a distinction between stepName version and stepState version + // A stepName could be compatible with a previous stepState version + Version = step.State.Version, + }; + } + + /// + /// Converts a StorageStepData to a KernelProcessStepState. + /// + /// + /// + public static KernelProcessStepState? ToKernelProcessStepState(this StorageStepData storageData) + { + var stepState = new KernelProcessStepState(stepId: storageData.StepInfo.StepName, version: storageData.StepInfo.Version, runId: storageData.InstanceId) + { + ParentId = storageData.StepInfo.ParentId, + }; + + if (storageData.StepState != null && !string.IsNullOrEmpty(storageData.StepState.StateType)) + { + var userStateType = Type.GetType(storageData.StepState.StateType); + if (userStateType != null && storageData.StepState.State != null) + { + var stateType = typeof(KernelProcessStepState<>).MakeGenericType(userStateType); + stepState = (KernelProcessStepState?)Activator.CreateInstance(stateType, stepState); + stateType.GetProperty(nameof(KernelProcessStepState.State))?.SetValue(stepState, storageData.StepState.State.ToObject()); + } + } + + return stepState; + } + + /// + /// Converts a KernelProcessStepInfo to a StorageStepState. + /// + /// + /// + public static StorageStepState? ToStorageStepState(this KernelProcessStepInfo step) + { + object? stepState = null; + var stateType = step.State.GetType(); + if (stateType.IsGenericType) + { + // it is a step with a custom state + stepState = stateType.GetProperty(nameof(KernelProcessStepState.State))?.GetValue(step.State); + + return new StorageStepState + { + State = KernelProcessEventData.FromObject(stepState), + StateType = stateType.GetGenericArguments()[0].AssemblyQualifiedName! + }; + } + + return null; + } + + /// + /// Converts edge group data to a StorageStepEvents. + /// + /// + /// + public static StorageStepEvents ToStorageStepEvents(Dictionary?>? edgeGroups = null) + { + return new StorageStepEvents + { + EdgesData = edgeGroups?.PackStepEdgesValues() + }; + } +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepInfo.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepInfo.cs new file mode 100644 index 000000000000..1fafefe86fd0 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepInfo.cs @@ -0,0 +1,26 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of a process state. +/// +public record StorageStepInfo : StorageEntryBase +{ + /// + /// Name of the process builder used to create the process instance + /// + [JsonPropertyName("stepName")] + public string StepName { get; set; } = string.Empty; + + /// + /// Id of the step parent process + /// + [JsonPropertyName("parentId")] + public string ParentId { get; set; } = string.Empty; + + [JsonPropertyName("version")] + public string Version { get; set; } = string.Empty; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepState.cs b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepState.cs new file mode 100644 index 000000000000..af5e5ec0a2b2 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/Models/Storage/StorageStepState.cs @@ -0,0 +1,28 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text.Json.Serialization; + +namespace Microsoft.SemanticKernel.Process.Models.Storage; + +/// +/// Storage representation of a step state. +/// +public record StorageStepState +{ + [JsonPropertyName("stateType")] + public string StateType { get; init; } = string.Empty; + + // Not needed if using KernelProcessEventData + ///// + ///// Version of the state that is stored. Used for validation and versioning + ///// purposes when reading a state and applying it to a ProcessStepBuilder/ProcessBuilder + ///// + //[JsonPropertyName("versionInfo")] + //public string VersionInfo { get; init; } = string.Empty; + + /// + /// The user-defined state object associated with the Step (if the step is stateful) -> Original object comes from StepStateMetadata + /// + [JsonPropertyName("state")] + public KernelProcessEventData? State { get; set; } = null; +} diff --git a/dotnet/src/Experimental/Process.Abstractions/Process.Abstractions.csproj b/dotnet/src/Experimental/Process.Abstractions/Process.Abstractions.csproj index f4af8d637107..745645e8e734 100644 --- a/dotnet/src/Experimental/Process.Abstractions/Process.Abstractions.csproj +++ b/dotnet/src/Experimental/Process.Abstractions/Process.Abstractions.csproj @@ -16,7 +16,8 @@ Semantic Kernel Process - Abstractions - Semantic Kernel Process abstractions. This package is automatically installed by Semantic Kernel Process packages if needed. + Semantic Kernel Process abstractions. This package is automatically installed by + Semantic Kernel Process packages if needed. @@ -43,4 +44,4 @@ - + \ No newline at end of file diff --git a/dotnet/src/Experimental/Process.Abstractions/ProcessStorageManager.cs b/dotnet/src/Experimental/Process.Abstractions/ProcessStorageManager.cs new file mode 100644 index 000000000000..ba35b430f5e6 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/ProcessStorageManager.cs @@ -0,0 +1,340 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Threading.Tasks; +using Microsoft.SemanticKernel.Process.Models.Storage; + +namespace Microsoft.SemanticKernel.Process; + +/// +/// Storage manager for storing step and process related data using the implementation of . +/// +public class ProcessStorageManager : IProcessStepStorageOperations, IProcessStorageOperations +{ + internal static class StorageKeywords + { + // Types + /// + /// To be used for storing process children data, parent info and external events + /// + public const string ProcessDetails = nameof(ProcessDetails); + + public const string StepDetails = nameof(StepDetails); + } + + private readonly IProcessStorageConnector _storageConnector; + + private bool _isInitialized = false; + + private readonly ConcurrentDictionary _softSaveStorage = []; + + /// + /// Constructor for the class. + /// + /// + public ProcessStorageManager(IProcessStorageConnector storageConnector) + { + this._storageConnector = storageConnector; + } + + /// + /// Initialize the storage connection. + /// + /// + public async Task InitializeAsync() + { + if (this._isInitialized) + { + return true; + } + await this._storageConnector.OpenConnectionAsync().ConfigureAwait(false); + this._isInitialized = true; + + return this._isInitialized; + } + + /// + /// Close the storage connection. + /// + /// + public async Task CloseAsync() + { + if (!this._isInitialized) + { + return true; + } + await this._storageConnector.CloseConnectionAsync().ConfigureAwait(false); + this._isInitialized = false; + + return true; + } + + private string GetEntryId(string componentName, string componentId) + { + return $"{componentId}.{componentName}"; + } + + #region Process related methods + private string GetProcessEntryId(KernelProcess process) + { + Verify.NotNullOrWhiteSpace(process.StepId); + Verify.NotNullOrWhiteSpace(process.RunId); + + return $"{this.GetEntryId(process.StepId, process.RunId)}.{StorageKeywords.ProcessDetails}"; + //return process.RunId; + } + + private string GetStepEntryId(KernelProcessStepInfo stepInfo) + { + Verify.NotNullOrWhiteSpace(stepInfo.StepId); + Verify.NotNullOrWhiteSpace(stepInfo.RunId); + + return $"{this.GetEntryId(stepInfo.StepId, stepInfo.RunId)}.{StorageKeywords.StepDetails}"; + //return step.RunId; + } + + /// + public async Task FetchProcessDataAsync(KernelProcess process) + { + var entryId = this.GetProcessEntryId(process); + + var storageState = await this._storageConnector.GetEntryAsync(entryId).ConfigureAwait(false); + if (storageState != null) + { + this._softSaveStorage[entryId] = storageState; + } + } + + /// + public Task GetProcessInfoAsync(KernelProcess process) + { + var entryId = this.GetProcessEntryId(process); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveProcessData) && softSaveProcessData is StorageProcessData processData) + { + return Task.FromResult(processData.ProcessInfo); + } + return Task.FromResult(null); + } + + /// + public Task SaveProcessInfoAsync(KernelProcess process) + { + Verify.NotNullOrWhiteSpace(process.RunId); + + var entryId = this.GetProcessEntryId(process); + if (!this._softSaveStorage.TryGetValue(entryId, out var processSavedData)) + { + processSavedData = new StorageProcessData() { InstanceId = process.RunId }; + this._softSaveStorage.TryAdd(entryId, processSavedData); + } + + if (processSavedData is StorageProcessData processData) + { + processData.ProcessInfo = process.ToKernelStorageProcessInfo(); + } + + return Task.FromResult(true); + } + + /// + public Task?> GetProcessExternalEventsAsync(KernelProcess process) + { + var entryId = this.GetProcessEntryId(process); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveProcessData) && softSaveProcessData is StorageProcessData processData) + { + return Task.FromResult?>(processData.ProcessEvents?.ExternalPendingMessages); + } + + return Task.FromResult?>(null); + } + + /// + public Task SaveProcessEventsAsync(KernelProcess process, List? pendingExternalEvents = null) + { + Verify.NotNullOrWhiteSpace(process.RunId); + + var entryId = this.GetProcessEntryId(process); + if (!this._softSaveStorage.TryGetValue(entryId, out var processSavedData)) + { + processSavedData = new StorageProcessData() { InstanceId = process.RunId }; + this._softSaveStorage.TryAdd(entryId, processSavedData); + } + + if (processSavedData is StorageProcessData processData) + { + processData.ProcessEvents = StorageProcessExtension.ToKernelStorageProcessEvents(pendingExternalEvents); + } + + return Task.FromResult(true); + } + + /// + public Task?> GetProcessStateVariablesAsync(KernelProcess process) + { + var entryId = this.GetProcessEntryId(process); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveStepData) && softSaveStepData is StorageProcessData processData) + { + var processState = processData.ProcessState.ToKernelProcessSharedVariables(); + return Task.FromResult?>(processState); + } + + return Task.FromResult?>(null); + } + + /// + public Task SaveProcessStateAsync(KernelProcess process, Dictionary sharedVariables) + { + Verify.NotNullOrWhiteSpace(process.RunId); + + var entryId = this.GetProcessEntryId(process); + + if (!this._softSaveStorage.TryGetValue(entryId, out var processSavedData)) + { + processSavedData = new StorageProcessData() { InstanceId = process.RunId }; + this._softSaveStorage.TryAdd(entryId, processSavedData); + } + + if (processSavedData is StorageProcessData processData) + { + processData.ProcessState = StorageProcessExtension.ToKernelStorageProcessState(sharedVariables); + } + + return Task.FromResult(true); + } + + /// + public async Task SaveProcessDataToStorageAsync(KernelProcess process) + { + var entryId = this.GetProcessEntryId(process); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveProcessData) && softSaveProcessData is StorageProcessData processData) + { + // for now process only has one entry - in the future the process state may be saved in a separate entity -> 2 storage calls + return await this._storageConnector.SaveEntryAsync(entryId, StorageKeywords.ProcessDetails, processData).ConfigureAwait(false); + } + + return false; + } + + #endregion + #region Step related methods + + /// + public async Task FetchStepDataAsync(KernelProcessStepInfo stepInfo) + { + var entryId = this.GetStepEntryId(stepInfo); + var storageState = await this._storageConnector.GetEntryAsync(entryId).ConfigureAwait(false); + + if (storageState != null) + { + this._softSaveStorage[entryId] = storageState; + } + } + + /// + public Task GetStepInfoAsync(KernelProcessStepInfo stepInfo) + { + var entryId = this.GetStepEntryId(stepInfo); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveStepData) && softSaveStepData is StorageStepData stepData) + { + return Task.FromResult(stepData.StepInfo); + } + return Task.FromResult(null); + } + + /// + public Task SaveStepInfoAsync(KernelProcessStepInfo stepInfo) + { + Verify.NotNullOrWhiteSpace(stepInfo.RunId); + + var entryId = this.GetStepEntryId(stepInfo); + if (!this._softSaveStorage.TryGetValue(entryId, out var stepSavedData)) + { + stepSavedData = new StorageStepData() { InstanceId = stepInfo.RunId }; + this._softSaveStorage.TryAdd(entryId, stepSavedData); + } + + if (stepSavedData is StorageStepData stepData) + { + stepData.StepInfo = stepInfo.ToStorageStepInfo(); + } + + return Task.FromResult(true); + } + + /// + public Task GetStepStateAsync(KernelProcessStepInfo stepInfo) + { + var entryId = this.GetStepEntryId(stepInfo); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveStepData) && softSaveStepData is StorageStepData stepData) + { + return Task.FromResult(stepData.ToKernelProcessStepState()); + } + + return Task.FromResult(null); + } + + /// + public Task SaveStepStateAsync(KernelProcessStepInfo stepInfo) + { + Verify.NotNullOrWhiteSpace(stepInfo.RunId); + + var entryId = this.GetStepEntryId(stepInfo); + + if (!this._softSaveStorage.TryGetValue(entryId, out var stepSavedData)) + { + stepSavedData = new StorageStepData() { InstanceId = stepInfo.RunId }; + this._softSaveStorage.TryAdd(entryId, stepSavedData); + } + + if (stepSavedData is StorageStepData stepData) + { + stepData.StepState = stepInfo.ToStorageStepState(); + } + + return Task.FromResult(true); + } + + /// + public Task GetStepEventsAsync(KernelProcessStepInfo stepInfo) + { + var entryId = this.GetStepEntryId(stepInfo); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveStepData) && softSaveStepData is StorageStepData stepData) + { + return Task.FromResult(stepData.StepEvents); + } + + return Task.FromResult(null); + } + + /// + public Task SaveStepEventsAsync(KernelProcessStepInfo stepInfo, Dictionary>? edgeGroups = null) + { + Verify.NotNullOrWhiteSpace(stepInfo.RunId); + var entryId = this.GetStepEntryId(stepInfo); + + if (!this._softSaveStorage.TryGetValue(entryId, out var stepSavedData)) + { + stepSavedData = new StorageStepData() { InstanceId = stepInfo.RunId }; + this._softSaveStorage.TryAdd(entryId, stepSavedData); + } + if (stepSavedData is StorageStepData stepData && edgeGroups != null) + { + stepData.StepEvents = StorageStepExtensions.ToStorageStepEvents(edgeGroups!); + } + return Task.FromResult(true); + } + + /// + public async Task SaveStepDataToStorageAsync(KernelProcessStepInfo stepInfo) + { + var entryId = this.GetStepEntryId(stepInfo); + if (this._softSaveStorage.TryGetValue(entryId, out var softSaveStepData) && softSaveStepData is StorageStepData stepData) + { + return await this._storageConnector.SaveEntryAsync(entryId, StorageKeywords.StepDetails, stepData).ConfigureAwait(false); + } + + return false; + } + #endregion +} diff --git a/dotnet/src/Experimental/Process.Abstractions/StepState.cs b/dotnet/src/Experimental/Process.Abstractions/StepState.cs new file mode 100644 index 000000000000..ff2dcf2f4b28 --- /dev/null +++ b/dotnet/src/Experimental/Process.Abstractions/StepState.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Runtime.Serialization; + +namespace Microsoft.SemanticKernel; + +/// +/// The state of a step +/// +[DataContract] +public class StepState +{ + /// + /// The step Id + /// + [DataMember] + public string? Id { get; set; } + + /// + /// State + /// + [DataMember] + public object? State { get; set; } +} diff --git a/dotnet/src/Experimental/Process.Core/FoundryProcessBuilder.cs b/dotnet/src/Experimental/Process.Core/FoundryProcessBuilder.cs index ea80d4d060b6..8b4dfe5ed753 100644 --- a/dotnet/src/Experimental/Process.Core/FoundryProcessBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/FoundryProcessBuilder.cs @@ -13,7 +13,6 @@ using Azure.Identity; using Microsoft.SemanticKernel.Agents; using Microsoft.SemanticKernel.Agents.AzureAI; -using Microsoft.SemanticKernel.Process.Models; namespace Microsoft.SemanticKernel; @@ -173,9 +172,9 @@ public FoundryListenForTargetBuilder OnProcessEnter() /// /// An instance of /// - public KernelProcess Build(KernelProcessStateMetadata? stateMetadata = null) + public KernelProcess Build() { - return this._processBuilder.Build(stateMetadata); + return this._processBuilder.Build(); } /// diff --git a/dotnet/src/Experimental/Process.Core/Internal/EndStep.cs b/dotnet/src/Experimental/Process.Core/Internal/EndStep.cs index 7e11c8247800..72627b5cafe7 100644 --- a/dotnet/src/Experimental/Process.Core/Internal/EndStep.cs +++ b/dotnet/src/Experimental/Process.Core/Internal/EndStep.cs @@ -2,7 +2,6 @@ using System.Collections.Generic; using Microsoft.SemanticKernel.Process.Internal; -using Microsoft.SemanticKernel.Process.Models; namespace Microsoft.SemanticKernel; @@ -30,7 +29,7 @@ internal override Dictionary GetFunctionMetadata return []; } - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { // The end step has no state. return new KernelProcessStepInfo(typeof(KernelProcessStepState), new KernelProcessStepState(ProcessConstants.EndStepName, version: ProcessConstants.InternalStepsVersion), []); diff --git a/dotnet/src/Experimental/Process.Core/Internal/KernelProcessStateMetadataExtension.cs b/dotnet/src/Experimental/Process.Core/Internal/KernelProcessStateMetadataExtension.cs index 59c66ac9d0e8..5265d06db757 100644 --- a/dotnet/src/Experimental/Process.Core/Internal/KernelProcessStateMetadataExtension.cs +++ b/dotnet/src/Experimental/Process.Core/Internal/KernelProcessStateMetadataExtension.cs @@ -8,25 +8,12 @@ namespace Microsoft.SemanticKernel.Process.Internal; internal static class KernelProcessStateMetadataExtension { - public static List BuildWithStateMetadata(this ProcessBuilder processBuilder, KernelProcessStateMetadata? stateMetadata) + public static List BuildWithStateMetadata(this ProcessBuilder processBuilder) { List builtSteps = []; - // 1- Validate StateMetadata: Migrate previous state versions if needed + sanitize state - KernelProcessStateMetadata? sanitizedMetadata = null; - if (stateMetadata != null) - { - sanitizedMetadata = SanitizeProcessStateMetadata(processBuilder, stateMetadata, processBuilder.Steps); - } - // 2- Build steps info with validated stateMetadata foreach (ProcessStepBuilder step in processBuilder.Steps) { - if (sanitizedMetadata != null && sanitizedMetadata.StepsState != null && sanitizedMetadata.StepsState.TryGetValue(step.Name, out var stepStateObject) && stepStateObject != null) - { - builtSteps.Add(step.BuildStep(processBuilder, stepStateObject)); - continue; - } - builtSteps.Add(step.BuildStep(processBuilder)); } @@ -41,9 +28,9 @@ private static KernelProcessStateMetadata SanitizeProcessStateMetadata(ProcessBu // 1- find matching key name with exact match or by alias match string? stepKey = null; - if (sanitizedStateMetadata.StepsState != null && sanitizedStateMetadata.StepsState.ContainsKey(step.Name)) + if (sanitizedStateMetadata.StepsState != null && sanitizedStateMetadata.StepsState.ContainsKey(step.StepId)) { - stepKey = step.Name; + stepKey = step.StepId; } else { @@ -58,12 +45,12 @@ private static KernelProcessStateMetadata SanitizeProcessStateMetadata(ProcessBu var currentVersionStateMetadata = step.BuildStep(processBuilder).ToProcessStateMetadata(); if (sanitizedStateMetadata.StepsState!.TryGetValue(stepKey, out var savedStateMetadata)) { - if (stepKey != step.Name) + if (stepKey != step.StepId) { if (savedStateMetadata.VersionInfo == currentVersionStateMetadata.VersionInfo) { // key mismatch only, but same version - sanitizedStateMetadata.StepsState[step.Name] = savedStateMetadata; + sanitizedStateMetadata.StepsState[step.StepId] = savedStateMetadata; // TODO: Should there be state formatting check too? } else @@ -72,12 +59,12 @@ private static KernelProcessStateMetadata SanitizeProcessStateMetadata(ProcessBu if (step is ProcessBuilder subprocessBuilder) { KernelProcessStateMetadata sanitizedStepState = SanitizeProcessStateMetadata(processBuilder, (KernelProcessStateMetadata)savedStateMetadata, subprocessBuilder.Steps); - sanitizedStateMetadata.StepsState[step.Name] = sanitizedStepState; + sanitizedStateMetadata.StepsState[step.StepId] = sanitizedStepState; } else if (step is ProcessMapBuilder mapBuilder) { KernelProcessStateMetadata sanitizedStepState = SanitizeProcessStateMetadata(processBuilder, (KernelProcessStateMetadata)savedStateMetadata, [mapBuilder.MapOperation]); - sanitizedStateMetadata.StepsState[step.Name] = sanitizedStepState; + sanitizedStateMetadata.StepsState[step.StepId] = sanitizedStepState; } else if (false) { @@ -86,14 +73,14 @@ private static KernelProcessStateMetadata SanitizeProcessStateMetadata(ProcessBu else { // no compatible state found, migrating id only - sanitizedStateMetadata.StepsState[step.Name] = new KernelProcessStepStateMetadata() + sanitizedStateMetadata.StepsState[step.StepId] = new KernelProcessStepStateMetadata() { - Name = step.Name, - Id = step.Id, + Name = step.StepId, + Id = step.StepId, }; } } - sanitizedStateMetadata.StepsState[step.Name].Name = step.Name; + sanitizedStateMetadata.StepsState[step.StepId].Name = step.StepId; sanitizedStateMetadata.StepsState.Remove(stepKey); } } diff --git a/dotnet/src/Experimental/Process.Core/ListenForBuilder.cs b/dotnet/src/Experimental/Process.Core/ListenForBuilder.cs index 6694701f18c7..f8cd2aa8c319 100644 --- a/dotnet/src/Experimental/Process.Core/ListenForBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ListenForBuilder.cs @@ -84,7 +84,7 @@ public ListenForTargetBuilder AllOf(List messageSources) private string GetGroupId(List messageSources) { var sortedKeys = messageSources - .Select(source => $"{source.Source.Id}.{source.MessageType}") + .Select(source => $"{source.Source.StepId}.{source.MessageType}") .OrderBy(id => id, StringComparer.OrdinalIgnoreCase) .ToList(); diff --git a/dotnet/src/Experimental/Process.Core/ListenForTargetBuilder.cs b/dotnet/src/Experimental/Process.Core/ListenForTargetBuilder.cs index afd99ea21456..df9570fbb01a 100644 --- a/dotnet/src/Experimental/Process.Core/ListenForTargetBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ListenForTargetBuilder.cs @@ -88,7 +88,20 @@ internal override ProcessStepEdgeBuilder SendEventTo_Internal(ProcessTargetBuild } // Link all the source steps to the event listener - var onEventBuilder = messageSource.Source.OnEvent(messageSource.MessageType); + ProcessStepEdgeBuilder? onEventBuilder = null; + + if (messageSource.Source is ProcessBuilder processSource && !processSource.HasParentProcess) + { + // process has no parent, it is root process an only output event from root is external input events + onEventBuilder = processSource.OnInputEvent(messageSource.MessageType); + } + else + { + // if it is a process and has parent process, process is seen as step by other steps. + // if it is a step it seen as step by other steps + onEventBuilder = messageSource.Source.OnEvent(messageSource.MessageType); + } + onEventBuilder.EdgeGroupBuilder = this.EdgeGroupBuilder; if (messageSource.Condition != null) diff --git a/dotnet/src/Experimental/Process.Core/ProcessAgentBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessAgentBuilder.cs index 91e295cdff08..7f77a715c417 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessAgentBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessAgentBuilder.cs @@ -10,7 +10,6 @@ using Json.Schema; using Json.Schema.Generation; using Microsoft.SemanticKernel.Agents; -using Microsoft.SemanticKernel.Process.Models; namespace Microsoft.SemanticKernel; @@ -208,10 +207,8 @@ public ProcessAgentBuilder WithUserStateInput(Expressi #endregion - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { - KernelProcessMapStateMetadata? mapMetadata = stateMetadata as KernelProcessMapStateMetadata; - // Build the edges first var builtEdges = this.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Select(e => e.Build()).ToList()); var agentActions = new ProcessAgentActions( @@ -226,14 +223,19 @@ internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, OnError = this.OnErrorBuilder?.Build() }); - var state = new KernelProcessStepState(this.Name, "1.0", this.Id); + var state = new KernelProcessStepState(this.StepId, "1.0", this.StepId); return new KernelProcessAgentStep(this._agentDefinition, agentActions, state, builtEdges, this.DefaultThreadName, this.Inputs) { AgentIdResolver = this.AgentIdResolver, HumanInLoopMode = this.HumanInLoopMode }; } internal ProcessFunctionTargetBuilder GetInvokeAgentFunctionTargetBuilder() { - return new ProcessFunctionTargetBuilder(this, functionName: KernelProcessAgentExecutor.ProcessFunctions.Invoke, parameterName: "message"); + return new ProcessFunctionTargetBuilder(this, functionName: KernelProcessAgentExecutor.ProcessFunctions.Invoke, parameterName: Constants.MessageParameterName); + } + + internal static class Constants + { + public const string MessageParameterName = "message"; } } diff --git a/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs index 830ed59f141c..2b72d156ac4c 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs @@ -8,7 +8,6 @@ using Microsoft.SemanticKernel.Agents.AzureAI; using Microsoft.SemanticKernel.Process; using Microsoft.SemanticKernel.Process.Internal; -using Microsoft.SemanticKernel.Process.Models; using Microsoft.SemanticKernel.Process.Tools; namespace Microsoft.SemanticKernel; @@ -130,12 +129,11 @@ internal override Dictionary GetFunctionMetadata /// Builds the step. /// /// ProcessBuilder to build the step for - /// State to apply to the step on the build process /// - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { // The step is a, process so we can return the step info directly. - return this.Build(stateMetadata as KernelProcessStateMetadata); + return this.Build(); } /// @@ -154,7 +152,7 @@ internal void AddStepFromBuilder(ProcessStepBuilder stepBuilder) /// private bool StepNameAlreadyExists(string stepName) { - return this._steps.Select(step => step.Name).Contains(stepName); + return this._steps.Select(step => step.StepId).Contains(stepName); } /// @@ -162,9 +160,9 @@ private bool StepNameAlreadyExists(string stepName) /// private TBuilder AddStep(TBuilder builder, IReadOnlyList? aliases) where TBuilder : ProcessStepBuilder { - if (this.StepNameAlreadyExists(builder.Name)) + if (this.StepNameAlreadyExists(builder.StepId)) { - throw new InvalidOperationException($"Step name {builder.Name} is already used, assign a different name for step"); + throw new InvalidOperationException($"Step name {builder.StepId} is already used, assign a different name for step"); } if (aliases != null && aliases.Count > 0) @@ -480,7 +478,7 @@ public ProcessEdgeBuilder OnError() /// Creates a instance to define a listener for incoming messages. /// /// - internal ListenForBuilder ListenFor() + public ListenForBuilder ListenFor() { return new ListenForBuilder(this); } @@ -497,12 +495,12 @@ public ProcessFunctionTargetBuilder WhereInputEventIs(string eventId) if (!this._externalEventTargetMap.TryGetValue(eventId, out var target)) { - throw new KernelException($"The process named '{this.Name}' does not expose an event with Id '{eventId}'."); + throw new KernelException($"The process named '{this.StepId}' does not expose an event with Id '{eventId}'."); } if (target is not ProcessFunctionTargetBuilder functionTargetBuilder) { - throw new KernelException($"The process named '{this.Name}' does not expose an event with Id '{eventId}'."); + throw new KernelException($"The process named '{this.StepId}' does not expose an event with Id '{eventId}'."); } // Targets for external events on a process should be scoped to the process itself rather than the step inside the process. @@ -514,16 +512,17 @@ public ProcessFunctionTargetBuilder WhereInputEventIs(string eventId) /// Builds the process. /// /// An instance of - public KernelProcess Build(KernelProcessStateMetadata? stateMetadata = null) + /// + public KernelProcess Build() { // Build the edges first var builtEdges = this.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Select(e => e.Build()).ToList()); - // Build the steps and injecting initial state if any is provided - var builtSteps = this.BuildWithStateMetadata(stateMetadata); + // Build the steps + var builtSteps = this.BuildWithStateMetadata(); // Create the process - KernelProcessState state = new(this.Name, version: this.Version, id: this.Id); + KernelProcessState state = new(this.StepId, version: this.Version); KernelProcess process = new(state, builtSteps, builtEdges) { Threads = this._threads, UserStateType = this.StateType, Description = this.Description }; return process; diff --git a/dotnet/src/Experimental/Process.Core/ProcessEdgeBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessEdgeBuilder.cs index a1da7cdf7d66..f1f61469332d 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessEdgeBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessEdgeBuilder.cs @@ -29,13 +29,21 @@ internal ProcessEdgeBuilder(ProcessBuilder source, string eventId) : base(source /// public ProcessEdgeBuilder SendEventTo(ProcessFunctionTargetBuilder target) { - return this.SendEventTo(target as ProcessTargetBuilder); + return this.SendEventTo_Int(target as ProcessTargetBuilder); } /// /// Sends the output of the source step to the specified target when the associated event fires. /// public new ProcessEdgeBuilder SendEventTo(ProcessTargetBuilder target) + { + return this.SendEventTo_Int(target as ProcessTargetBuilder); + } + + /// + /// Sends the output of the source step to the specified target when the associated event fires. + /// + internal ProcessEdgeBuilder SendEventTo_Int(ProcessTargetBuilder target) { if (this.Target is not null) { diff --git a/dotnet/src/Experimental/Process.Core/ProcessExporter.cs b/dotnet/src/Experimental/Process.Core/ProcessExporter.cs index bd95513a5923..a0b951afa1fd 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessExporter.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessExporter.cs @@ -23,7 +23,7 @@ public static string ExportProcess(KernelProcess process) Workflow workflow = new() { - Name = process.State.Name, + Name = process.State.StepId, Description = process.Description, FormatVersion = "1.0", WorkflowVersion = process.State.Version, @@ -50,7 +50,7 @@ private static Node GetNodeFromStep(KernelProcessStepInfo stepInfo) { var agentNode = new Node() { - Id = agentStep.State.Id ?? throw new KernelException("All steps must have an Id."), + Id = agentStep.State.RunId ?? throw new KernelException("All steps must have an Id."), Description = agentStep.Description, Type = "agent", Inputs = agentStep.Inputs.ToDictionary((kvp) => kvp.Key, (kvp) => diff --git a/dotnet/src/Experimental/Process.Core/ProcessFunctionTargetBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessFunctionTargetBuilder.cs index d407e227eeca..58e0ae5fe479 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessFunctionTargetBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessFunctionTargetBuilder.cs @@ -136,7 +136,7 @@ public ProcessAgentInvokeTargetBuilder(ProcessStepBuilder step, string? threadEv internal override KernelProcessTarget Build(ProcessBuilder? processBuilder = null) { - return new KernelProcessAgentInvokeTarget(this.Step.Id, this.ThreadEval, this.MessagesInEval, this.InputEvals); + return new KernelProcessAgentInvokeTarget(this.Step.StepId, this.ThreadEval, this.MessagesInEval, this.InputEvals); } } @@ -146,12 +146,14 @@ internal override KernelProcessTarget Build(ProcessBuilder? processBuilder = nul public record ProcessFunctionTargetBuilder : ProcessTargetBuilder { /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class.
+ /// Constructor only meant to be used by internal SK Builders components to allow piping specific parameters if needed.
+ /// For external use, with should be used for mapping multiple parameters to a step function /// /// The step to target. /// The function to target. /// The parameter to target. - public ProcessFunctionTargetBuilder(ProcessStepBuilder step, string? functionName = null, string? parameterName = null) : base(ProcessTargetType.KernelFunction) + internal ProcessFunctionTargetBuilder(ProcessStepBuilder step, string? functionName, string? parameterName = null) : base(ProcessTargetType.KernelFunction) { Verify.NotNull(step, nameof(step)); @@ -169,21 +171,30 @@ public ProcessFunctionTargetBuilder(ProcessStepBuilder step, string? functionNam var target = step.ResolveFunctionTarget(functionName, parameterName); if (target == null) { - throw new InvalidOperationException($"Failed to resolve function target for {step.GetType().Name}, {step.Name}: Function - {functionName ?? "any"} / Parameter - {parameterName ?? "any"}"); + throw new InvalidOperationException($"Failed to resolve function target for {step.GetType().Name}, {step.StepId}: Function - {functionName ?? "any"} / Parameter - {parameterName ?? "any"}"); } this.FunctionName = target.FunctionName!; this.ParameterName = target.ParameterName; } + /// + /// Initializes a new instance of the class. + /// + /// The step to target. + /// The function to target. + public ProcessFunctionTargetBuilder(ProcessStepBuilder step, string? functionName = null) : this(step, functionName, step is ProcessAgentBuilder ? ProcessAgentBuilder.Constants.MessageParameterName : null) + { + } + /// /// Builds the function target. /// /// An instance of internal override KernelProcessTarget Build(ProcessBuilder? processBuilder = null) { - Verify.NotNull(this.Step.Id); - return new KernelProcessFunctionTarget(this.Step.Id, this.FunctionName, this.ParameterName, this.TargetEventId); + Verify.NotNull(this.Step.StepId); + return new KernelProcessFunctionTarget(this.Step.StepId, this.FunctionName, this.ParameterName, this.TargetEventId); } /// @@ -216,8 +227,9 @@ public sealed record ProcessStepTargetBuilder : ProcessFunctionTargetBuilder /// Initializes a new instance of the class. /// /// + /// /// - public ProcessStepTargetBuilder(ProcessStepBuilder stepBuilder, Func, Dictionary>? inputMapping = null) : base(stepBuilder) + public ProcessStepTargetBuilder(ProcessStepBuilder stepBuilder, string? functionName = null, Func, Dictionary>? inputMapping = null) : base(stepBuilder, functionName, null) { this.InputMapping = inputMapping ?? new Func, Dictionary>((input) => input); } diff --git a/dotnet/src/Experimental/Process.Core/ProcessMapBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessMapBuilder.cs index 93a25529fb38..5e6ab1bf108c 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessMapBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessMapBuilder.cs @@ -2,7 +2,6 @@ using System; using System.Collections.Generic; using System.Linq; -using Microsoft.SemanticKernel.Process.Models; namespace Microsoft.SemanticKernel; @@ -18,7 +17,7 @@ public sealed class ProcessMapBuilder : ProcessStepBuilder /// /// The target of the map operation. May target a step or process internal ProcessMapBuilder(ProcessStepBuilder mapOperation) - : base($"Map{mapOperation.Name}", mapOperation.ProcessBuilder) + : base($"Map{mapOperation.StepId}", mapOperation.ProcessBuilder) { this.MapOperation = mapOperation; } @@ -74,16 +73,14 @@ internal override KernelProcessFunctionTarget ResolveFunctionTarget(string? func } /// - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { - KernelProcessMapStateMetadata? mapMetadata = stateMetadata as KernelProcessMapStateMetadata; - // Build the edges first var builtEdges = this.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Select(e => e.Build()).ToList()); // Define the map state - KernelProcessMapState state = new(this.Name, this.Version, this.Id); + KernelProcessMapState state = new(this.StepId, this.Version, this.StepId); - return new KernelProcessMap(state, this.MapOperation.BuildStep(processBuilder, mapMetadata?.OperationState), builtEdges); + return new KernelProcessMap(state, this.MapOperation.BuildStep(processBuilder), builtEdges); } } diff --git a/dotnet/src/Experimental/Process.Core/ProcessProxyBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessProxyBuilder.cs index 28a5387cb510..301fddf0781f 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessProxyBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessProxyBuilder.cs @@ -45,7 +45,7 @@ internal ProcessProxyBuilder(IReadOnlyList externalTopics, string name, internal ProcessFunctionTargetBuilder GetExternalFunctionTargetBuilder() { - return new ProcessFunctionTargetBuilder(this, functionName: KernelProxyStep.ProcessFunctions.EmitExternalEvent, parameterName: "proxyEvent"); + return new ProcessFunctionTargetBuilder(this, functionName: KernelProxyStep.ProcessFunctions.EmitExternalEvent); } internal void LinkTopicToStepEdgeInfo(string topicName, ProcessStepBuilder sourceStep, ProcessEventData eventData) @@ -65,7 +65,7 @@ internal void LinkTopicToStepEdgeInfo(string topicName, ProcessStepBuilder sourc } /// - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { if (this._externalTopicUsage.All(topic => !topic.Value)) { @@ -74,8 +74,8 @@ internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessProxyStateMetadata proxyMetadata = new() { - Name = this.Name, - Id = this.Id, + Name = this.StepId, + Id = this.StepId, EventMetadata = this._eventMetadata, PublishTopics = this._externalTopicUsage.ToList().Select(topic => topic.Key).ToList(), }; @@ -83,7 +83,7 @@ internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, // Build the edges first var builtEdges = this.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Select(e => e.Build()).ToList()); - KernelProcessStepState state = new(this.Name, this.Version, this.Id); + KernelProcessStepState state = new(this.StepId, this.Version, this.StepId); return new KernelProcessProxy(state, builtEdges) { diff --git a/dotnet/src/Experimental/Process.Core/ProcessStepBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessStepBuilder.cs index d0a63da1a274..85096dbe4464 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessStepBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessStepBuilder.cs @@ -3,10 +3,8 @@ using System; using System.Collections.Generic; using System.Linq; -using System.Text.Json; using Microsoft.SemanticKernel.Process; using Microsoft.SemanticKernel.Process.Internal; -using Microsoft.SemanticKernel.Process.Models; namespace Microsoft.SemanticKernel; @@ -18,14 +16,10 @@ public abstract class ProcessStepBuilder #region Public Interface /// - /// The unique identifier for the step. This may be null until the step is run within a process. + /// The unique identifier for the step within a process. A process cannot have two steps with the same stepId. + /// This can be human-readable but is required to be unique within the process. /// - public string Id { get; } - - /// - /// The name of the step. This is intended to be a human-readable name and is not required to be unique. - /// - public string Name { get; } + public string StepId { get; } /// /// Alternative names that have been used to previous versions of the step @@ -49,6 +43,38 @@ public ProcessStepEdgeBuilder OnEvent(string eventId) return new ProcessStepEdgeBuilder(this, scopedEventId, eventId); } + /// + /// Returns the event Id that is used to identify the result of a function. + /// + /// Optional: name of the step function the result is expected from + /// + public string GetFunctionResultEventId(string? functionName = null) + { + // TODO: Add a check to see if the function name is valid if provided + if (string.IsNullOrWhiteSpace(functionName)) + { + functionName = this.ResolveFunctionName(); + } + return $"{functionName}.OnResult"; + } + + /// + /// Returns the event Id that is used to identify the step specific event. + /// + /// used for custom events emitted by step + /// used for return objects from specific function, if step has only 1 function no need to provide functionName + /// + public string GetFullEventId(string? eventName = null, string? functionName = null) + { + if (eventName == null) + { + // default function result are used + eventName = this.GetFunctionResultEventId(functionName); + } + + return $"{this.StepId}.{eventName}"; + } + /// /// Define the behavior of the step when the specified function has been successfully invoked. /// @@ -57,11 +83,8 @@ public ProcessStepEdgeBuilder OnEvent(string eventId) /// An instance of . public ProcessStepEdgeBuilder OnFunctionResult(string? functionName = null) { - if (string.IsNullOrWhiteSpace(functionName)) - { - functionName = this.ResolveFunctionName(); - } - return this.OnEvent($"{functionName}.OnResult"); + var eventId = this.GetFunctionResultEventId(functionName); + return this.OnEvent(eventId); } /// @@ -103,7 +126,7 @@ public ProcessStepEdgeBuilder OnFunctionError(string? functionName = null) /// Builds the step with step state /// /// an instance of . - internal abstract KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null); + internal abstract KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder); /// /// Registers a group input mapping for the step. @@ -130,11 +153,11 @@ private string ResolveFunctionName() { if (this.FunctionsDict.Count == 0) { - throw new KernelException($"The step {this.Name} has no functions."); + throw new KernelException($"The step {this.StepId} has no functions."); } else if (this.FunctionsDict.Count > 1) { - throw new KernelException($"The step {this.Name} has more than one function, so a function name must be provided."); + throw new KernelException($"The step {this.StepId} has more than one function, so a function name must be provided."); } return this.FunctionsDict.Keys.First(); @@ -156,6 +179,17 @@ internal virtual void LinkTo(string eventId, ProcessStepEdgeBuilder edgeBuilder) edges.Add(edgeBuilder); } + internal static bool FilterSupportedParameterTypes(Type? parameterType, bool hasDefaultValue = false) + { + if (parameterType != typeof(KernelProcessStepContext) && + parameterType != typeof(KernelProcessStepExternalContext)) + { + return !hasDefaultValue; + } + + return false; + } + /// /// Used to resolve the target function and parameter for a given optional function name and parameter name. /// This is used to simplify the process of creating a by making it possible @@ -172,7 +206,7 @@ internal virtual KernelProcessFunctionTarget ResolveFunctionTarget(string? funct if (this.FunctionsDict.Count == 0) { - throw new KernelException($"The target step {this.Name} has no functions."); + throw new KernelException($"The target step {this.StepId} has no functions."); } // If the function name is null or whitespace, then there can only one function on the step @@ -180,7 +214,7 @@ internal virtual KernelProcessFunctionTarget ResolveFunctionTarget(string? funct { if (this.FunctionsDict.Count > 1) { - throw new KernelException("The target step has more than one function, so a function name must be provided."); + throw new KernelException($"The target step {this.StepId} has more than one function, so a function name must be provided."); } verifiedFunctionName = this.FunctionsDict.Keys.First(); @@ -189,13 +223,13 @@ internal virtual KernelProcessFunctionTarget ResolveFunctionTarget(string? funct // Verify that the target function exists if (!this.FunctionsDict.TryGetValue(verifiedFunctionName!, out var kernelFunctionMetadata) || kernelFunctionMetadata is null) { - throw new KernelException($"The function {functionName} does not exist on step {this.Name}"); + throw new KernelException($"The function {functionName} does not exist on step {this.StepId}"); } // If the parameter name is null or whitespace, then the function must have 0 or 1 parameters if (string.IsNullOrWhiteSpace(verifiedParameterName)) { - var undeterminedParameters = kernelFunctionMetadata.Parameters.Where(p => p.ParameterType != typeof(KernelProcessStepContext)).ToList(); + var undeterminedParameters = kernelFunctionMetadata.Parameters.Where(p => FilterSupportedParameterTypes(p.ParameterType, hasDefaultValue: p.DefaultValue != null)).ToList(); if (undeterminedParameters.Count > 1) { @@ -214,7 +248,7 @@ internal virtual KernelProcessFunctionTarget ResolveFunctionTarget(string? funct Verify.NotNull(verifiedFunctionName); return new KernelProcessFunctionTarget( - stepId: this.Id!, + stepId: this.StepId!, functionName: verifiedFunctionName, parameterName: verifiedParameterName ); @@ -246,10 +280,10 @@ protected ProcessStepBuilder(string id, ProcessBuilder? processBuilder) { Verify.NotNullOrWhiteSpace(id, nameof(id)); - this.Id ??= id; - this.Name = id; + this.StepId ??= id; + this.StepId = id; this.FunctionsDict = []; - this._eventNamespace = this.Id; + this._eventNamespace = this.StepId; this.Edges = new Dictionary>(StringComparer.OrdinalIgnoreCase); this.ProcessBuilder = processBuilder; } @@ -263,7 +297,7 @@ public class ProcessStepBuilderTyped : ProcessStepBuilder /// /// The initial state of the step. This may be null if the step does not have any state. /// - private object? _initialState; + private readonly object? _initialState; private readonly Type _stepType; @@ -288,7 +322,7 @@ internal ProcessStepBuilderTyped(Type stepType, string id, ProcessBuilder? proce /// Builds the step with a state if provided /// /// An instance of - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { KernelProcessStepState? stateObject = null; KernelProcessStepMetadataAttribute stepMetadataAttributes = KernelProcessStepMetadataFactory.ExtractProcessStepMetadataFromType(this._stepType); @@ -303,32 +337,20 @@ internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, var stateType = typeof(KernelProcessStepState<>).MakeGenericType(userStateType); Verify.NotNull(stateType); - if (stateMetadata != null && stateMetadata.State != null && stateMetadata.State is JsonElement jsonState) - { - try - { - this._initialState = jsonState.Deserialize(userStateType); - } - catch (JsonException) - { - throw new KernelException($"The initial state provided for step {this.Name} is not of the correct type. The expected type is {userStateType.Name}."); - } - } - // If the step has a user-defined state then we need to validate that the initial state is of the correct type. if (this._initialState is not null && this._initialState.GetType() != userStateType) { - throw new KernelException($"The initial state provided for step {this.Name} is not of the correct type. The expected type is {userStateType.Name}."); + throw new KernelException($"The initial state provided for step {this.StepId} is not of the correct type. The expected type is {userStateType.Name}."); } var initialState = this._initialState ?? Activator.CreateInstance(userStateType); - stateObject = (KernelProcessStepState?)Activator.CreateInstance(stateType, this.Name, stepMetadataAttributes.Version, this.Id); + stateObject = (KernelProcessStepState?)Activator.CreateInstance(stateType, this.StepId, stepMetadataAttributes.Version, null); stateType.GetProperty(nameof(KernelProcessStepState.State))?.SetValue(stateObject, initialState); } else { // The step is a KernelProcessStep with no user-defined state, so we can use the base KernelProcessStepState. - stateObject = new KernelProcessStepState(this.Name, stepMetadataAttributes.Version, this.Id); + stateObject = new KernelProcessStepState(this.StepId, stepMetadataAttributes.Version); } Verify.NotNull(stateObject); diff --git a/dotnet/src/Experimental/Process.Core/ProcessStepEdgeBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessStepEdgeBuilder.cs index d37350743b23..27be7eb24e35 100644 --- a/dotnet/src/Experimental/Process.Core/ProcessStepEdgeBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/ProcessStepEdgeBuilder.cs @@ -62,9 +62,9 @@ internal ProcessStepEdgeBuilder(ProcessStepBuilder source, string eventId, strin /// internal KernelProcessEdge Build(ProcessBuilder? processBuilder = null) { - Verify.NotNull(this.Source?.Id); + Verify.NotNull(this.Source?.StepId); - if (this.Target is null || this.Source?.Id is null) + if (this.Target is null || this.Source?.StepId is null) { throw new InvalidOperationException("A target and Source must be specified before building the edge."); } @@ -73,13 +73,13 @@ internal KernelProcessEdge Build(ProcessBuilder? processBuilder = null) { if (this.EdgeGroupBuilder is not null && this.Target is ProcessStepTargetBuilder stepTargetBuilder) { - var messageSources = this.EdgeGroupBuilder.MessageSources.Select(e => new KernelProcessMessageSource(e.MessageType, e.Source.Id)).ToList(); + var messageSources = this.EdgeGroupBuilder.MessageSources.Select(e => new KernelProcessMessageSource(e.MessageType, e.Source.StepId)).ToList(); var edgeGroup = new KernelProcessEdgeGroup(this.EdgeGroupBuilder.GroupId, messageSources, stepTargetBuilder.InputMapping); functionTargetBuilder.Step.RegisterGroupInputMapping(edgeGroup); } } - return new KernelProcessEdge(this.Source.Id, this.Target.Build(processBuilder), groupId: this.EdgeGroupBuilder?.GroupId, this.Condition, this.VariableUpdate); + return new KernelProcessEdge(this.Source.StepId, this.Target.Build(processBuilder), groupId: this.EdgeGroupBuilder?.GroupId, this.Condition, this.VariableUpdate); } /// diff --git a/dotnet/src/Experimental/Process.Core/Tools/ProcessVisualizationExtensions.cs b/dotnet/src/Experimental/Process.Core/Tools/ProcessVisualizationExtensions.cs index acaed115a092..3be6f1101213 100644 --- a/dotnet/src/Experimental/Process.Core/Tools/ProcessVisualizationExtensions.cs +++ b/dotnet/src/Experimental/Process.Core/Tools/ProcessVisualizationExtensions.cs @@ -64,10 +64,10 @@ private static string RenderProcess(KernelProcess process, int level, bool isSub // Dictionary to map step IDs to step names var stepNames = process.Steps - .Where(step => step.State.Id != null && step.State.Name != null) + .Where(step => step.State.RunId != null && step.State.StepId != null) .ToDictionary( - step => step.State.Id!, - step => step.State.Name! + step => step.State.RunId!, + step => step.State.StepId! ); // Add Start and End nodes only if this is not a sub-process @@ -80,8 +80,8 @@ private static string RenderProcess(KernelProcess process, int level, bool isSub // Process each step foreach (var step in process.Steps) { - var stepId = step.State.Id; - var stepName = step.State.Name; + var stepId = step.State.RunId; + var stepName = step.State.StepId; // Check if the step is a nested process (sub-process) if (step is KernelProcess nestedProcess && level < maxLevel) @@ -115,7 +115,7 @@ private static string RenderProcess(KernelProcess process, int level, bool isSub var stepEdges = kvp.Value; // Skip drawing edges that point to a nested process as an entry point - if (stepNames.ContainsKey(eventId) && process.Steps.Any(s => s.State.Name == eventId && s is KernelProcess)) + if (stepNames.ContainsKey(eventId) && process.Steps.Any(s => s.State.StepId == eventId && s is KernelProcess)) { continue; } @@ -156,8 +156,8 @@ private static string RenderProcess(KernelProcess process, int level, bool isSub // Connect Start to the first step and the last step to End (only for the main process) if (!isSubProcess && process.Steps.Count > 0) { - var firstStepName = process.Steps.First().State.Name; - var lastStepName = process.Steps.Last().State.Name; + var firstStepName = process.Steps.First().State.StepId; + var lastStepName = process.Steps.Last().State.StepId; sb.AppendLine($"{indentation}Start --> {firstStepName}[\"{firstStepName}\"]"); sb.AppendLine($"{indentation}{lastStepName}[\"{lastStepName}\"] --> End"); diff --git a/dotnet/src/Experimental/Process.Core/Workflow/WorkflowBuilder.cs b/dotnet/src/Experimental/Process.Core/Workflow/WorkflowBuilder.cs index 38d9d2b90a00..79131f1e5474 100644 --- a/dotnet/src/Experimental/Process.Core/Workflow/WorkflowBuilder.cs +++ b/dotnet/src/Experimental/Process.Core/Workflow/WorkflowBuilder.cs @@ -325,10 +325,10 @@ public static Task BuildWorkflow(KernelProcess process) Workflow workflow = new() { - Id = process.State.Id ?? throw new KernelException("The process must have an Id set"), + Id = process.State.RunId ?? throw new KernelException("The process must have an Id set"), Description = process.Description, FormatVersion = "1.0", - Name = process.State.Name, + Name = process.State.StepId, Nodes = [new Node { Id = "End", Type = "declarative", Version = "1.0", Description = "Terminal state" }], Variables = [], }; @@ -403,7 +403,7 @@ public static Task BuildWorkflow(KernelProcess process) private static Node BuildNode(KernelProcessStepInfo step, List orchestrationSteps) { - Verify.NotNullOrWhiteSpace(step?.State?.Id, nameof(step.State.Id)); + Verify.NotNullOrWhiteSpace(step?.State?.RunId, nameof(step.State.RunId)); if (step is KernelProcessAgentStep agentStep) { @@ -418,12 +418,12 @@ private static Node BuildNode(KernelProcessStepInfo step, List /// The process to start. /// - public required DaprProcessInfo Process { get; set; } + public DaprProcessInfo? Process { get; set; } /// /// The initial event to send to the process. diff --git a/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Controllers/ProcessTestController.cs b/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Controllers/ProcessTestController.cs index ff90188e1de7..083e310af5dc 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Controllers/ProcessTestController.cs +++ b/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Controllers/ProcessTestController.cs @@ -19,14 +19,17 @@ public class ProcessTestController : Controller { private static readonly Dictionary s_processes = new(); private readonly Kernel _kernel; + private readonly DaprKernelProcessFactory _daprKernelProcessFactory; /// /// Initializes a new instance of the class. /// /// - public ProcessTestController(Kernel kernel) + /// + public ProcessTestController(Kernel kernel, DaprKernelProcessFactory daprKernelProcessFactory2) { this._kernel = kernel; + this._daprKernelProcessFactory = daprKernelProcessFactory2; } /// @@ -34,22 +37,34 @@ public ProcessTestController(Kernel kernel) /// /// The Id of the process /// The request + /// The registration key of the Processes. /// - [HttpPost("processes/{processId}")] - public async Task StartProcessAsync(string processId, [FromBody] ProcessStartRequest request) + [HttpPost("processes/{processKey}/{processId}")] + public async Task StartProcessAsync(string processId, [FromBody] ProcessStartRequest request, string? processKey = null) { - if (s_processes.ContainsKey(processId)) + try { - return this.BadRequest("Process already started"); - } + if (s_processes.ContainsKey(processId)) + { + return this.BadRequest("Process already started"); + } - KernelProcessEvent initialEvent = request.InitialEvent.ToKernelProcessEvent(); + if (string.IsNullOrWhiteSpace(processKey)) + { + return this.BadRequest("Process key is required for Dapr runtime."); + } - var kernelProcess = request.Process.ToKernelProcess(); - var context = await kernelProcess.StartAsync(initialEvent); - s_processes.Add(processId, context); + KernelProcessEvent initialEvent = request.InitialEvent.ToKernelProcessEvent(); - return this.Ok(); + var context = await this._daprKernelProcessFactory.StartAsync(processKey, processId, initialEvent); + s_processes.Add(processId, context); + + return this.Ok(); + } + catch (Exception) + { + throw; + } } /// @@ -60,17 +75,48 @@ public async Task StartProcessAsync(string processId, [FromBody] [HttpGet("processes/{processId}")] public async Task GetProcessAsync(string processId) { - if (!s_processes.TryGetValue(processId, out DaprKernelProcessContext? context)) + try { - return this.NotFound(); - } + if (!s_processes.TryGetValue(processId, out DaprKernelProcessContext? context)) + { + return this.NotFound(); + } + + var process = await context.GetStateAsync(); + var daprProcess = DaprProcessInfo.FromKernelProcess(process); - var process = await context.GetStateAsync(); - var daprProcess = DaprProcessInfo.FromKernelProcess(process); + var serialized = JsonSerializer.Serialize(daprProcess); + + return this.Ok(daprProcess); + } + catch (Exception) + { + throw; + } + } - var serialized = JsonSerializer.Serialize(daprProcess); + /// + /// Retrieves information about a process. + /// + /// The Id of the process. + /// + [HttpGet("processes/{processId}/stepStates")] + public async Task GetProcessStepStatesAsync(string processId) + { + try + { + if (!s_processes.TryGetValue(processId, out DaprKernelProcessContext? context)) + { + return this.NotFound(); + } - return this.Ok(daprProcess); + var processStepStates = await context.GetStepStatesAsync(); + return this.Ok(processStepStates); + } + catch (Exception) + { + throw; + } } /// diff --git a/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/ProcessStateTypeResolver.cs b/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/ProcessStateTypeResolver.cs index 3069dd47087e..0a897f0a3281 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/ProcessStateTypeResolver.cs +++ b/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/ProcessStateTypeResolver.cs @@ -82,7 +82,8 @@ public override JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions option { new JsonDerivedType(typeof(DaprProcessInfo), nameof(DaprProcessInfo)), new JsonDerivedType(typeof(DaprMapInfo), nameof(DaprMapInfo)), - new JsonDerivedType(typeof(DaprProxyInfo), nameof(DaprProxyInfo)), + new JsonDerivedType(typeof(DaprAgentStepInfo), nameof(DaprAgentStepInfo)), + new JsonDerivedType(typeof(DaprProxyInfo), nameof(DaprProxyInfo)) } }; } diff --git a/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Program.cs b/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Program.cs index 76b4d862f197..9d8578ce61a9 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Program.cs +++ b/dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Program.cs @@ -1,9 +1,12 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Diagnostics; using Microsoft.SemanticKernel; using SemanticKernel.Process.IntegrationTests; using SemanticKernel.Process.TestsShared.CloudEvents; +Debugger.Break(); + var builder = WebApplication.CreateBuilder(args); // Configure logging @@ -20,7 +23,8 @@ builder.Services.AddSingleton(MockCloudEventClient.Instance); builder.Services.AddSingleton(MockCloudEventClient.Instance); -// Configure Dapr +// Configure the Process Framework and Dapr +builder.Services.AddDaprKernelProcesses(); builder.Services.AddActors(static options => { // Register the actors required to run Processes @@ -28,6 +32,15 @@ options.Actors.RegisterActor(); }); +var process = ProcessResources.GetCStepProcess(); +builder.Services.AddKeyedSingleton(process.State.StepId, (sp, key) => +{ + return process; +}); + +// Register our processes +builder.Services.AddSingleton(); + builder.Services.AddControllers().AddJsonOptions(options => { options.JsonSerializerOptions.TypeInfoResolver = new ProcessStateTypeResolver(); @@ -37,4 +50,12 @@ app.MapControllers(); app.MapActorsHandlers(); -app.Run(); + +try +{ + app.Run(); +} +catch (Exception) +{ + throw; +} diff --git a/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/DaprTestProcessContext.cs b/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/DaprTestProcessContext.cs index 5b2e74d6f027..4ed002fab623 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/DaprTestProcessContext.cs +++ b/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/DaprTestProcessContext.cs @@ -4,6 +4,7 @@ using System.Text.Json; using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Process; +using Microsoft.SemanticKernel.Process.Internal; using Microsoft.SemanticKernel.Process.Serialization; using SemanticKernel.Process.TestsShared.CloudEvents; @@ -11,19 +12,49 @@ namespace SemanticKernel.Process.IntegrationTests; internal sealed class DaprTestProcessContext : KernelProcessContext { private readonly HttpClient _httpClient; - private readonly KernelProcess _process; + private readonly KernelProcess? _process; + private readonly string? _key; private readonly string _processId; private readonly JsonSerializerOptions _serializerOptions; + /// + /// Creates a new instance of the class. + /// + /// + /// internal DaprTestProcessContext(KernelProcess process, HttpClient httpClient) { - if (string.IsNullOrWhiteSpace(process.State.Id)) + if (string.IsNullOrWhiteSpace(process.State.RunId)) { - process = process with { State = process.State with { Id = Guid.NewGuid().ToString() } }; + process = process with { State = process.State with { RunId = Guid.NewGuid().ToString() } }; } this._process = process; - this._processId = process.State.Id; + this._processId = process.State.RunId; + this._httpClient = httpClient; + + this._serializerOptions = new JsonSerializerOptions() + { + TypeInfoResolver = new ProcessStateTypeResolver(), + PropertyNamingPolicy = JsonNamingPolicy.CamelCase + }; + } + + /// + /// Creates a new instance of the class. + /// + /// + /// + /// + internal DaprTestProcessContext(KernelProcess process, string runId, HttpClient httpClient) + { + Verify.NotNull(process); + Verify.NotNullOrWhiteSpace(runId); + Verify.NotNull(httpClient); + + this._key = process.State.StepId; + this._processId = process.State.StepId; + this._process = process; this._httpClient = httpClient; this._serializerOptions = new JsonSerializerOptions() @@ -40,10 +71,47 @@ internal DaprTestProcessContext(KernelProcess process, HttpClient httpClient) /// internal async Task StartWithEventAsync(KernelProcessEvent initialEvent) { - var daprProcess = DaprProcessInfo.FromKernelProcess(this._process); - var request = new ProcessStartRequest { Process = daprProcess, InitialEvent = initialEvent.ToJson() }; + if (this._process is null) + { + throw new InvalidOperationException("Process is not set"); + } + + try + { + var daprProcess = DaprProcessInfo.FromKernelProcess(this._process); + var request = new ProcessStartRequest { Process = daprProcess, InitialEvent = initialEvent.ToJson() }; + + var response = await this._httpClient.PostAsJsonAsync($"http://localhost:5200/processes/{this._processId}", request, options: this._serializerOptions).ConfigureAwait(false); + if (!response.IsSuccessStatusCode) + { + throw new InvalidOperationException("Failed to start process"); + } + } + catch (Exception) + { + throw; + } + } + + /// + /// Starts the process with an initial event. + /// + /// The process id. + /// The initial event. + /// + internal async Task StartKeyedWithEventAsync(string id, KernelProcessEvent initialEvent) + { + Verify.NotNullOrWhiteSpace(id); + Verify.NotNull(initialEvent); + + if (this._key is null) + { + throw new InvalidOperationException("Key is not set"); + } + + var request = new ProcessStartRequest { InitialEvent = initialEvent.ToJson() }; - var response = await this._httpClient.PostAsJsonAsync($"http://localhost:5200/processes/{this._processId}", request, options: this._serializerOptions).ConfigureAwait(false); + var response = await this._httpClient.PostAsJsonAsync($"http://localhost:5200/processes/{this._key}/{this._processId}", request, options: this._serializerOptions).ConfigureAwait(false); if (!response.IsSuccessStatusCode) { throw new InvalidOperationException("Failed to start process"); @@ -52,12 +120,17 @@ internal async Task StartWithEventAsync(KernelProcessEvent initialEvent) public override async Task GetStateAsync() { - var response = await this._httpClient.GetFromJsonAsync($"http://localhost:5200/processes/{this._processId}", options: this._serializerOptions); - return response switch + IDictionary stepStates = await this.GetStepStatesAsync(); + + // Build the process with the new state + List kernelProcessSteps = []; + + foreach (var step in this._process.Steps) { - null => throw new InvalidOperationException("Process not found"), - _ => response.ToKernelProcess() - }; + kernelProcessSteps.Add(step with { State = stepStates[step.State.StepId] }); + } + + return this._process with { Steps = kernelProcessSteps }; } public override Task SendEventAsync(KernelProcessEvent processEvent) @@ -80,5 +153,72 @@ public override Task StopAsync() }; } - public override Task GetProcessIdAsync() => Task.FromResult(this._process.State.Id!); + public override Task GetProcessIdAsync() => Task.FromResult(this._process?.State.RunId!); + + public override async Task> GetStepStatesAsync() + { + var response = await this._httpClient.GetStringAsync($"http://localhost:5200/processes/{this._processId}/stepStates"); + + try + { + Dictionary dict = new(); + using var document = JsonDocument.Parse(response); + JsonElement root = document.RootElement; + if (root.ValueKind != JsonValueKind.Object) + { + throw new InvalidOperationException("Incorrect format of States response."); + } + + // Iterate through each property in the root object + foreach (JsonProperty property in root.EnumerateObject()) + { + string key = property.Name; + JsonElement valueElement = property.Value; + + // Extract the raw JSON text for this property value + string valueJson = RemoveStateTypeProperty(valueElement); + + // Get the associated process step + var step = this._process!.Steps.Where(s => s.State.StepId == key).Single(); + var stateType = step.InnerStepType.ExtractStateType(out Type? userStateType, null); + + // Determine the state type and deserialize accordingly + KernelProcessStepState? stepState = JsonSerializer.Deserialize(valueJson, stateType) as KernelProcessStepState; + + dict.Add(key, stepState); + } + + return dict; + } + catch (Exception) + { + throw; + } + } + + private static string RemoveStateTypeProperty(JsonElement element) + { + using (var stream = new System.IO.MemoryStream()) + { + using (var writer = new Utf8JsonWriter(stream)) + { + writer.WriteStartObject(); + + foreach (JsonProperty property in element.EnumerateObject()) + { + // Skip the $state-type property + if (property.Name == "$state-type") + { + continue; + } + + property.WriteTo(writer); + } + + writer.WriteEndObject(); + } + + return System.Text.Encoding.UTF8.GetString(stream.ToArray()); + } + } } diff --git a/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/Process.IntegrationTestRunner.Dapr.csproj b/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/Process.IntegrationTestRunner.Dapr.csproj index 7f28b56abfe9..0da030fb72f8 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/Process.IntegrationTestRunner.Dapr.csproj +++ b/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/Process.IntegrationTestRunner.Dapr.csproj @@ -24,6 +24,7 @@ + @@ -42,6 +43,7 @@ runtime; build; native; contentfiles; analyzers; buildtransitive all + diff --git a/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/ProcessTestFixture.cs b/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/ProcessTestFixture.cs index c6f55eb95f69..a47ce3145c1f 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/ProcessTestFixture.cs +++ b/dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/ProcessTestFixture.cs @@ -2,6 +2,7 @@ using System.Diagnostics; using System.Net; +using System.Text; using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Process; using Xunit; @@ -32,6 +33,7 @@ public async Task InitializeAsync() /// private async Task StartTestHostAsync() { + var sb = new StringBuilder(); try { string workingDirectory = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), @"..\..\..\..\Process.IntegrationTestHost.Dapr")); @@ -40,9 +42,9 @@ private async Task StartTestHostAsync() FileName = "dapr", Arguments = "run --app-id daprprocesstests --app-port 5200 --dapr-http-port 3500 -- dotnet run --urls http://localhost:5200", WorkingDirectory = workingDirectory, - RedirectStandardOutput = false, - RedirectStandardError = false, - UseShellExecute = true, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, CreateNoWindow = false }; @@ -51,11 +53,22 @@ private async Task StartTestHostAsync() StartInfo = processStartInfo }; + // hookup the eventhandlers to capture the data that is received + this._process.OutputDataReceived += (sender, args) => sb.AppendLine(args.Data); + this._process.ErrorDataReceived += (sender, args) => sb.AppendLine(args.Data); + this._process.Start(); + + // start our event pumps + this._process.BeginOutputReadLine(); + this._process.BeginErrorReadLine(); + await this.WaitForHostStartupAsync(); } catch (Exception) { + string output = sb.ToString(); + Console.WriteLine(output); throw; } } @@ -115,19 +128,12 @@ private async Task WaitForHostStartupAsync() throw new InvalidProgramException("Dapr Test Host did not start"); } - /// - /// Starts a process. - /// - /// The process to start. - /// An instance of - /// An optional initial event. - /// channel used for external messages - /// A - public async Task StartProcessAsync(KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null) + /// + public async Task StartProcessAsync(KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null, string? runId = null) { - // Actual Kernel injection of Kernel and ExternalKernelProcessMessageChannel is in dotnet\src\Experimental\Process.IntegrationTestHost.Dapr\Program.cs - var context = new DaprTestProcessContext(process, this._httpClient!); - await context.StartWithEventAsync(initialEvent); + runId ??= Guid.NewGuid().ToString(); + var context = new DaprTestProcessContext(process, runId, this._httpClient!); + await context.StartKeyedWithEventAsync(process.State.StepId, initialEvent); return context; } diff --git a/dotnet/src/Experimental/Process.IntegrationTestRunner.Local/ProcessTestFixture.cs b/dotnet/src/Experimental/Process.IntegrationTestRunner.Local/ProcessTestFixture.cs index fc9b16e4ad50..fc88869ef354 100644 --- a/dotnet/src/Experimental/Process.IntegrationTestRunner.Local/ProcessTestFixture.cs +++ b/dotnet/src/Experimental/Process.IntegrationTestRunner.Local/ProcessTestFixture.cs @@ -19,10 +19,11 @@ public class ProcessTestFixture /// An instance of /// An optional initial event. /// channel used for external messages + /// The Id of the run. /// A - public async Task StartProcessAsync(KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null) + public async Task StartProcessAsync(KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null, string? runId = null) { - return await process.StartAsync(kernel, initialEvent, externalMessageChannel); + return await process.StartAsync(kernel, initialEvent, externalMessageChannel: externalMessageChannel); } /// diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessCycleTestResources.cs b/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessCycleTestResources.cs index bc8a23ebe61a..1061ec2e7ebb 100644 --- a/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessCycleTestResources.cs +++ b/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessCycleTestResources.cs @@ -3,6 +3,7 @@ using System; using System.Linq; using System.Runtime.Serialization; +using System.Text.Json.Serialization; using System.Threading; using System.Threading.Tasks; using Microsoft.SemanticKernel; @@ -91,6 +92,7 @@ public async ValueTask DoItAsync(KernelProcessStepContext context, string astepd public sealed record CStepState { [DataMember] + [JsonPropertyName("currentCycle")] public int CurrentCycle { get; set; } } @@ -150,6 +152,7 @@ public sealed class EmitterStep : KernelProcessStep public const string InternalEventFunction = "SomeInternalFunctionName"; public const string PublicEventFunction = "SomePublicFunctionName"; public const string DualInputPublicEventFunction = "SomeDualInputPublicEventFunctionName"; + public const string QuadInputPublicEventFunction = "SomeQuadInputPublicEventFunctionName"; private readonly int _sleepDurationMs = 150; @@ -166,7 +169,7 @@ public async Task InternalTestFunctionAsync(KernelProcessStepContext context, st { Thread.Sleep(this._sleepDurationMs); - Console.WriteLine($"[EMIT_INTERNAL] {data}"); + Console.WriteLine($"[EMIT_INTERNAL-{this.StepName}] {data}"); this._state!.LastMessage = data; await context.EmitEventAsync(new() { Id = EventId, Data = data }); } @@ -176,7 +179,7 @@ public async Task PublicTestFunctionAsync(KernelProcessStepContext context, stri { Thread.Sleep(this._sleepDurationMs); - Console.WriteLine($"[EMIT_PUBLIC] {data}"); + Console.WriteLine($"[EMIT_PUBLIC-{this.StepName}] {data}"); this._state!.LastMessage = data; await context.EmitEventAsync(new() { Id = PublicEventId, Data = data, Visibility = KernelProcessEventVisibility.Public }); } @@ -187,10 +190,21 @@ public async Task DualInputPublicTestFunctionAsync(KernelProcessStepContext cont Thread.Sleep(this._sleepDurationMs); string outputText = $"{firstInput}-{secondInput}"; - Console.WriteLine($"[EMIT_PUBLIC_DUAL] {outputText}"); + Console.WriteLine($"[EMIT_PUBLIC_DUAL-{this.StepName}] {outputText}"); this._state!.LastMessage = outputText; await context.EmitEventAsync(new() { Id = ProcessTestsEvents.OutputReadyPublic, Data = outputText, Visibility = KernelProcessEventVisibility.Public }); } + + [KernelFunction(QuadInputPublicEventFunction)] + public async Task QuadInputPublicEventFunctionAsync(KernelProcessStepContext context, string firstInput, string secondInput, string thirdInput = "thirdInput", string fourthInput = "fourthInput") + { + Thread.Sleep(this._sleepDurationMs * 2); + + string outputText = $"{firstInput}-{secondInput}-{thirdInput}-{fourthInput}"; + Console.WriteLine($"[EMIT_PUBLIC_QUAD-{this.StepName}] {outputText}"); + this._state!.LastMessage = outputText; + await context.EmitEventAsync(new() { Id = ProcessTestsEvents.OutputReadySecondaryPublic, Data = outputText, Visibility = KernelProcessEventVisibility.Public }); + } } /// @@ -320,8 +334,10 @@ public sealed record StepState public static class ProcessTestsEvents { public const string StartProcess = "StartProcess"; + public const string SecondaryStartProcess = "SecondaryStartProcess"; public const string StartInnerProcess = "StartInnerProcess"; public const string OutputReadyPublic = "OutputReadyPublic"; + public const string OutputReadySecondaryPublic = "OutputReadySecondaryPublic"; public const string OutputReadyInternal = "OutputReadyInternal"; public const string ErrorStepSuccess = "ErrorStepSuccess"; } diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessResources.cs b/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessResources.cs new file mode 100644 index 000000000000..9d907ca7ee25 --- /dev/null +++ b/dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessResources.cs @@ -0,0 +1,75 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Microsoft.SemanticKernel; + +namespace SemanticKernel.Process.IntegrationTests; + +/// +/// This class contains resources for the process integration tests. +/// +public static class ProcessResources +{ + /// + /// Creates a kernel process with steps A, B, and C. + /// + /// + public static KernelProcess GetCStepProcess() + { + // Create the process builder. + ProcessBuilder processBuilder = new("ProcessWithDapr"); + + // Add some steps to the process. + var kickoffStep = processBuilder.AddStepFromType(id: "kickoffStep"); + var myAStep = processBuilder.AddStepFromType(id: "aStep"); + var myBStep = processBuilder.AddStepFromType(id: "bStep"); + + // ########## Configuring initial state on steps in a process ########### + // For demonstration purposes, we add the CStep and configure its initial state with a CurrentCycle of 1. + // Initializing state in a step can be useful for when you need a step to start out with a predetermines + // configuration that is not easily accomplished with dependency injection. + var myCStep = processBuilder.AddStepFromType(initialState: new() { CurrentCycle = 1 }, id: "cStep"); + + // Setup the input event that can trigger the process to run and specify which step and function it should be routed to. + processBuilder + .OnInputEvent(CommonEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); + + // When the kickoff step is finished, trigger both AStep and BStep. + kickoffStep + .OnEvent(CommonEvents.StartARequested) + .SendEventTo(new ProcessFunctionTargetBuilder(myAStep)) + .SendEventTo(new ProcessFunctionTargetBuilder(myBStep)); + + // When step A and step B have finished, trigger the CStep. + processBuilder + .ListenFor() + .AllOf(new() + { + new(messageType: CommonEvents.AStepDone, source: myAStep), + new(messageType: CommonEvents.BStepDone, source: myBStep) + }) + .SendEventTo(new ProcessStepTargetBuilder(myCStep, inputMapping: (inputEvents) => + { + // Map the input events to the CStep's input parameters. + // In this case, we are mapping the output of AStep to the first input parameter of CStep + // and the output of BStep to the second input parameter of CStep. + return new() + { + { "astepdata", inputEvents[$"aStep.{CommonEvents.AStepDone}"] }, + { "bstepdata", inputEvents[$"bStep.{CommonEvents.BStepDone}"] } + }; + })); + + // When CStep has finished without requesting an exit, activate the Kickoff step to start again. + myCStep + .OnEvent(CommonEvents.CStepDone) + .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); + + // When the CStep has finished by requesting an exit, stop the process. + myCStep + .OnEvent(CommonEvents.ExitRequested) + .StopProcess(); + + return processBuilder.Build(); + } +} diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCloudEventsTests.cs b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCloudEventsTests.cs index 818b90acfdf4..4d3331efbce7 100644 --- a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCloudEventsTests.cs +++ b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCloudEventsTests.cs @@ -187,8 +187,8 @@ private ProcessBuilder CreateLinearProcessWithEmitTopic(string name) .SendEventTo(new ProcessFunctionTargetBuilder(echoStep)); echoStep - .OnFunctionResult(nameof(CommonSteps.EchoStep.Echo)) - .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep, parameterName: "message")); + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep)); echoStep .OnFunctionResult() diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCycleTests.cs b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCycleTests.cs index f12079a24a33..2746e7d7dcf8 100644 --- a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCycleTests.cs +++ b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessCycleTests.cs @@ -54,13 +54,19 @@ public async Task TestCycleAndExitWithFanInAsync() .OnEvent(CommonEvents.StartBRequested) .SendEventTo(new ProcessFunctionTargetBuilder(myBStep)); - myAStep - .OnEvent(CommonEvents.AStepDone) - .SendEventTo(new ProcessFunctionTargetBuilder(myCStep, parameterName: "astepdata")); - - myBStep - .OnEvent(CommonEvents.BStepDone) - .SendEventTo(new ProcessFunctionTargetBuilder(myCStep, parameterName: "bstepdata")); + process.ListenFor().AllOf( + [ + new(CommonEvents.AStepDone, myAStep), + new(CommonEvents.BStepDone, myBStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(myCStep, inputMapping: (inputEvents) => + { + return new() + { + { "astepdata", inputEvents[myAStep.GetFullEventId(CommonEvents.AStepDone)] }, + { "bstepdata", inputEvents[myBStep.GetFullEventId(CommonEvents.BStepDone)] } + }; + })); myCStep .OnEvent(CommonEvents.CStepDone) @@ -74,7 +80,7 @@ public async Task TestCycleAndExitWithFanInAsync() var processContext = await this._fixture.StartProcessAsync(kernelProcess, kernel, new KernelProcessEvent() { Id = CommonEvents.StartProcess, Data = "foo" }); var processState = await processContext.GetStateAsync(); - var cStepState = processState.Steps.Where(s => s.State.Name == "CStep").FirstOrDefault()?.State as KernelProcessStepState; + var cStepState = processState.Steps.Where(s => s.State.StepId == "CStep").FirstOrDefault()?.State as KernelProcessStepState; Assert.NotNull(cStepState?.State); Assert.Equal(3, cStepState.State.CurrentCycle); diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessMapTests.cs b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessMapTests.cs index 3213ad57b237..2dff0528c83b 100644 --- a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessMapTests.cs +++ b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessMapTests.cs @@ -65,7 +65,7 @@ await this._fixture.StartProcessAsync( // Assert KernelProcess processState = await processContext.GetStateAsync(); - KernelProcessStepState unionState = (KernelProcessStepState)processState.Steps.Where(s => s.State.Name == "Union").Single().State; + KernelProcessStepState unionState = (KernelProcessStepState)processState.Steps.Where(s => s.State.StepId == "Union").Single().State; Assert.NotNull(unionState?.State); Assert.Equal(55L, unionState.State.SquareResult); @@ -106,7 +106,7 @@ public async Task TestMapWithProcessAsync() // Act KernelProcessContext processContext = await this._fixture.StartProcessAsync( - processInstance with { State = processInstance.State with { Id = Guid.NewGuid().ToString() } }, + processInstance with { State = processInstance.State with { RunId = Guid.NewGuid().ToString() } }, kernel, new KernelProcessEvent() { @@ -116,7 +116,7 @@ await this._fixture.StartProcessAsync( // Assert KernelProcess processState = await processContext.GetStateAsync(); - KernelProcessStepState unionState = (KernelProcessStepState)processState.Steps.Where(s => s.State.Name == "Union").Single().State; + KernelProcessStepState unionState = (KernelProcessStepState)processState.Steps.Where(s => s.State.StepId == "Union").Single().State; Assert.NotNull(unionState?.State); Assert.Equal(55L, unionState.State.SquareResult); diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTestFixture.cs b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTestFixture.cs index e7e37b4149c5..35b0a9fb4b33 100644 --- a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTestFixture.cs +++ b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTestFixture.cs @@ -18,8 +18,9 @@ public abstract class ProcessTestFixture /// An instance of /// An optional initial event. /// channel used for external messages + /// An optional run Id. /// A - public abstract Task StartProcessAsync(KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null); + public abstract Task StartProcessAsync(KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null, string? runId = null); /// /// Starts the specified process. diff --git a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTests.cs b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTests.cs index 24932e1e72e6..8ce0b24ebab3 100644 --- a/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTests.cs +++ b/dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTests.cs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft. All rights reserved. #pragma warning disable IDE0005 // Using directive is unnecessary. +using System; +using System.Diagnostics; using System.Linq; using System.Threading.Tasks; using Microsoft.Extensions.Configuration; @@ -61,6 +63,113 @@ public async Task LinearProcessAsync() this.AssertStepStateLastMessage(processInfo, nameof(RepeatStep), expectedLastMessage: string.Join(" ", Enumerable.Repeat(testInput, 2))); } + /// + /// Tests a simple process with a WhenAll event listener + /// + /// + [Fact] + public async Task ProcessWithWhenAllListenerAsync() + { + // Arrange + OpenAIConfiguration configuration = this._configuration.GetSection("OpenAI").Get()!; + this._kernelBuilder.AddOpenAIChatCompletion( + modelId: configuration.ModelId!, + apiKey: configuration.ApiKey); + + Kernel kernel = this._kernelBuilder.Build(); + var process = this.GetProcess().Build(); + + // Act + string testInput = "Test"; + var processHandle = await this._fixture.StartProcessAsync(process, new(), new() { Id = ProcessTestsEvents.StartProcess, Data = testInput }, runId: Guid.NewGuid().ToString()); + + var processInfo = await processHandle.GetStateAsync(); + + // Assert + this.AssertStepState(processInfo, "cStep", (KernelProcessStepState state) => state.State?.CurrentCycle == 3); + } + + /// + /// Tests a process with a WhenAll listener and a step that has multiple functions and parameters. + /// + /// A + [Fact] + public async Task ProcessWithWhenAllListenerAndStepWithMultipleFunctionsAndParametersUsingOnlyOneMultiParamFunctionAsync() + { + // Arrange + OpenAIConfiguration configuration = this._configuration.GetSection("OpenAI").Get()!; + this._kernelBuilder.AddOpenAIChatCompletion( + modelId: configuration.ModelId!, + apiKey: configuration.ApiKey); + + Kernel kernel = this._kernelBuilder.Build(); + + var processBuilder = this.CreateProcessWithFanInUsingStepWithMultipleFunctionsAndParameters("testProcess"); + var process = processBuilder.Build(); + + // Act + string testInput = "Test"; + var processHandle = await this._fixture.StartProcessAsync(process, kernel, new() { Id = ProcessTestsEvents.StartProcess, Data = testInput }); + + // Assert + var processInfo = await processHandle.GetStateAsync(); + this.AssertStepStateLastMessage(processInfo, "emitterStep", expectedLastMessage: $"{testInput} {testInput}-{testInput}"); + } + + /// + /// Tests a process with a WhenAll listener and a step that has multiple functions and parameters. + /// + /// A + [Fact] + public async Task ProcessWithWhenAllListenerAndStepWithMultipleFunctionsAndParametersUsingOnlyTwoMultiParamFunctionsFromStepsAndInputEventsAsync() + { + // Arrange + OpenAIConfiguration configuration = this._configuration.GetSection("OpenAI").Get()!; + this._kernelBuilder.AddOpenAIChatCompletion( + modelId: configuration.ModelId!, + apiKey: configuration.ApiKey); + + Kernel kernel = this._kernelBuilder.Build(); + + var processBuilder = this.CreateProcessWithFanInUsingStepWithMultipleFunctionsAndParametersSimultaneouslyFromStepsAndInputEvents("testProcess"); + var process = processBuilder.Build(); + + // Act + string testInput = "Test"; + var processHandle = await this._fixture.StartProcessAsync(process, kernel, new() { Id = ProcessTestsEvents.StartProcess, Data = testInput }); + + // Assert + var processInfo = await processHandle.GetStateAsync(); + this.AssertStepStateLastMessage(processInfo, "fanInStep", expectedLastMessage: $"{testInput}-{testInput}-{testInput} {testInput}-{testInput}-thirdInput-someFixedInputFromProcessDefinition"); + } + + /// + /// Tests a process with a WhenAll listener and a step that has multiple functions and parameters. + /// + /// A + [Fact] + public async Task ProcessWithWhenAllListenerAndStepWithMultipleFunctionsAndParametersUsingOnlyTwoMultiParamFunctionsFromStepsOnlyAsync() + { + // Arrange + OpenAIConfiguration configuration = this._configuration.GetSection("OpenAI").Get()!; + this._kernelBuilder.AddOpenAIChatCompletion( + modelId: configuration.ModelId!, + apiKey: configuration.ApiKey); + + Kernel kernel = this._kernelBuilder.Build(); + + var processBuilder = this.CreateProcessWithFanInUsingStepWithMultipleFunctionsAndParametersSimultaneouslyFromStepsOnly("testProcess"); + var process = processBuilder.Build(); + + // Act + string testInput = "Test"; + var processHandle = await this._fixture.StartProcessAsync(process, kernel, new() { Id = ProcessTestsEvents.StartProcess, Data = testInput }); + + // Assert + var processInfo = await processHandle.GetStateAsync(); + this.AssertStepStateLastMessage(processInfo, "fanInStep", expectedLastMessage: $"{testInput} {testInput}-{testInput}-{testInput} {testInput}-{testInput}-thirdInput-someFixedInputFromProcessDefinition"); + } + /// /// Tests a process with three steps where the third step is a nested process. Ev/ts from the outer process /// are routed to the inner process. @@ -96,7 +205,7 @@ public async Task NestedProcessOuterToInnerWorksAsync() var processInfo = await processHandle.GetStateAsync(); // Assert - var innerProcess = processInfo.Steps.Where(s => s.State.Name == "Inner").Single() as KernelProcess; + var innerProcess = processInfo.Steps.Where(s => s.State.StepId == "Inner").Single() as KernelProcess; Assert.NotNull(innerProcess); this.AssertStepStateLastMessage(innerProcess, nameof(RepeatStep), expectedLastMessage: string.Join(" ", Enumerable.Repeat(testInput, 4))); } @@ -251,7 +360,7 @@ public async Task StepAndFanInProcessAsync() var processInfo = await processHandle.GetStateAsync(); // Assert - var subprocessStepInfo = processInfo.Steps.Where(s => s.State.Name == fanInStepName)?.FirstOrDefault() as KernelProcess; + var subprocessStepInfo = processInfo.Steps.Where(s => s.State.StepId == fanInStepName)?.FirstOrDefault() as KernelProcess; Assert.NotNull(subprocessStepInfo); this.AssertStepStateLastMessage(subprocessStepInfo, nameof(FanInStep), expectedLastMessage: $"{testInput}-{testInput} {testInput}"); } @@ -304,12 +413,22 @@ public async Task ProcessWith2NestedSubprocessSequentiallyAndMultipleOutputSteps .SendEventTo(new ProcessFunctionTargetBuilder(outputStep2, functionName: EmitterStep.PublicEventFunction)); thirdStep .OnEvent(ProcessTestsEvents.OutputReadyPublic) - .SendEventTo(new ProcessFunctionTargetBuilder(lastStep, parameterName: "secondInput")) .SendEventTo(new ProcessFunctionTargetBuilder(outputStep3, functionName: EmitterStep.PublicEventFunction)); - firstStep - .OnEvent(EmitterStep.EventId) - .SendEventTo(new ProcessFunctionTargetBuilder(lastStep, parameterName: "firstInput")); + processBuilder.ListenFor().AllOf( + [ + new(EmitterStep.EventId, firstStep), + new(ProcessTestsEvents.OutputReadyPublic, thirdStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(lastStep, inputMapping: (inputEvents) => + { + // Map the inputs to the last step. + return new() + { + { "firstInput", inputEvents[firstStep.GetFullEventId(EmitterStep.EventId)] }, + { "secondInput", inputEvents[thirdStep.GetFullEventId(ProcessTestsEvents.OutputReadyPublic)] } + }; + })); KernelProcess process = processBuilder.Build(); @@ -327,6 +446,275 @@ public async Task ProcessWith2NestedSubprocessSequentiallyAndMultipleOutputSteps #region Predefined ProcessBuilders for testing + private ProcessBuilder GetProcess() + { + // Create the process builder. + ProcessBuilder processBuilder = new("ProcessWithDapr"); + + // Add some steps to the process. + var kickoffStep = processBuilder.AddStepFromType(id: "kickoffStep"); + var myAStep = processBuilder.AddStepFromType(id: "aStep"); + var myBStep = processBuilder.AddStepFromType(id: "bStep"); + + // ########## Configuring initial state on steps in a process ########### + // For demonstration purposes, we add the CStep and configure its initial state with a CurrentCycle of 1. + // Initializing state in a step can be useful for when you need a step to start out with a predetermines + // configuration that is not easily accomplished with dependency injection. + var myCStep = processBuilder.AddStepFromType(initialState: new() { CurrentCycle = 1 }, id: "cStep"); + + // Setup the input event that can trigger the process to run and specify which step and function it should be routed to. + processBuilder + .OnInputEvent(CommonEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); + + // When the kickoff step is finished, trigger both AStep and BStep. + kickoffStep + .OnEvent(CommonEvents.StartARequested) + .SendEventTo(new ProcessFunctionTargetBuilder(myAStep)) + .SendEventTo(new ProcessFunctionTargetBuilder(myBStep)); + + // When step A and step B have finished, trigger the CStep. + processBuilder + .ListenFor() + .AllOf(new() + { + new(messageType: CommonEvents.AStepDone, source: myAStep), + new(messageType: CommonEvents.BStepDone, source: myBStep) + }) + .SendEventTo(new ProcessStepTargetBuilder(myCStep, inputMapping: (inputEvents) => + { + // Map the input events to the CStep's input parameters. + // In this case, we are mapping the output of AStep to the first input parameter of CStep + // and the output of BStep to the second input parameter of CStep. + return new() + { + { "astepdata", inputEvents[$"aStep.{CommonEvents.AStepDone}"] }, + { "bstepdata", inputEvents[$"bStep.{CommonEvents.BStepDone}"] } + }; + })); + + // When CStep has finished without requesting an exit, activate the Kickoff step to start again. + myCStep + .OnEvent(CommonEvents.CStepDone) + .SendEventTo(new ProcessFunctionTargetBuilder(kickoffStep)); + + // When the CStep has finished by requesting an exit, stop the process. + myCStep + .OnEvent(CommonEvents.ExitRequested) + .StopProcess(); + + return processBuilder; + } + + /// + /// Sample process with a fan in step that takes the output of two steps and combines them.
+ /// Fan in step - emitter - has multiple functions and some have multiple parameters.
+ /// + /// ┌────────┐ + /// │ repeat ├───┐ + /// └────────┘ │ ┌─────────┐ + /// └──►│ │ + /// │ emitter │ + /// ┌──►│ │ + /// ┌────────┐ │ └─────────┘ + /// │ echo ├───┘ + /// └────────┘ + /// + /// + /// + /// + private ProcessBuilder CreateProcessWithFanInUsingStepWithMultipleFunctionsAndParameters(string name) + { + ProcessBuilder processBuilder = new(name); + ProcessStepBuilder repeatStep = processBuilder.AddStepFromType("repeatStep"); + ProcessStepBuilder echoStep = processBuilder.AddStepFromType("echoStep"); + ProcessStepBuilder emitterStep = processBuilder.AddStepFromType("emitterStep"); + + processBuilder + .OnInputEvent(ProcessTestsEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep)) + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep)); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.OutputReadyInternal, repeatStep), + new(echoStep.GetFunctionResultEventId(), echoStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(emitterStep, functionName: EmitterStep.DualInputPublicEventFunction, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[repeatStep.GetFullEventId(ProcessTestsEvents.OutputReadyInternal)] }, + { "secondInput", inputEvents[echoStep.GetFullEventId()] } + }; + })); + + return processBuilder; + } + + /// + /// Sample process with a fan in step that takes the output of two steps from same step and combines them.
+ /// Fan in step - emitter - has multiple functions and some have multiple parameters.
+ /// This test is meant to test the ability to create multiple internal edgeGroups in the same step.
+ /// + /// ┌────────┐ + /// │ repeat ├───┐ + /// └────────┘ │ ┌────────┐ ┌─────────┐ ┌─────────┐ + /// └►│ r_echo ├─►│ ├────►│ │ + /// └────────┘ │ emitter │ │ fanIn │ + /// ┌-───────────►│ ├────►│ │ + /// ┌────────┐ │ └─────────┘ └─────────┘ + /// │ echo ├───┘ + /// └────────┘ + /// + /// + /// + /// + private ProcessBuilder CreateProcessWithFanInUsingStepWithMultipleFunctionsAndParametersSimultaneouslyFromStepsAndInputEvents(string name) + { + ProcessBuilder processBuilder = new(name); + ProcessStepBuilder repeatStep = processBuilder.AddStepFromType("repeatStep"); + ProcessStepBuilder repeatEchoStep = processBuilder.AddStepFromType("repeatEchoStep"); + ProcessStepBuilder echoStep = processBuilder.AddStepFromType("echoStep"); + ProcessStepBuilder emitterStep = processBuilder.AddStepFromType("emitterStep"); + ProcessStepBuilder fanInStep = processBuilder.AddStepFromType("fanInStep"); + + processBuilder + .OnInputEvent(ProcessTestsEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep)) + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep)); + + repeatStep + .OnEvent(ProcessTestsEvents.OutputReadyInternal) + .SendEventTo(new ProcessFunctionTargetBuilder(repeatEchoStep)); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.StartProcess, processBuilder), + ]) + .SendEventTo(new ProcessStepTargetBuilder(emitterStep, functionName: EmitterStep.DualInputPublicEventFunction, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[processBuilder.GetFullEventId(ProcessTestsEvents.StartProcess)] }, + { "secondInput", inputEvents[processBuilder.GetFullEventId(ProcessTestsEvents.StartProcess)] } + }; + })); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.OutputReadyInternal, repeatStep), + new(echoStep.GetFunctionResultEventId(), echoStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(emitterStep, functionName: EmitterStep.QuadInputPublicEventFunction, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[repeatStep.GetFullEventId(ProcessTestsEvents.OutputReadyInternal)] }, + { "secondInput", inputEvents[echoStep.GetFullEventId()] }, + { "fourthInput", "someFixedInputFromProcessDefinition" }, + }; + })); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.OutputReadyPublic, emitterStep), + new(ProcessTestsEvents.OutputReadySecondaryPublic, emitterStep), + ]) + .SendEventTo(new ProcessStepTargetBuilder(fanInStep, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[emitterStep.GetFullEventId(ProcessTestsEvents.OutputReadyPublic)] }, + { "secondInput", inputEvents[emitterStep.GetFullEventId(ProcessTestsEvents.OutputReadySecondaryPublic)] } + }; + })); + + return processBuilder; + } + + /// + /// Sample process with a fan in step that takes the output of two steps from same step and combines them.
+ /// Fan in step - emitter - has multiple functions and some have multiple parameters.
+ /// This test is meant to test the ability to create multiple internal edgeGroups in the same step.
+ /// + /// ┌────────┐ + /// │ repeat ├───┐ + /// └────────┘ │ ┌────────┐ ┌─────────┐ ┌─────────┐ + /// └►│ r_echo ├─►│ ├────►│ │ + /// └────────┘ │ emitter │ │ fanIn │ + /// ┌-───────────►│ ├────►│ │ + /// ┌────────┐ │ └─────────┘ └─────────┘ + /// │ echo ├───┘ + /// └────────┘ + /// + /// + /// + /// + private ProcessBuilder CreateProcessWithFanInUsingStepWithMultipleFunctionsAndParametersSimultaneouslyFromStepsOnly(string name) + { + ProcessBuilder processBuilder = new(name); + ProcessStepBuilder repeatStep = processBuilder.AddStepFromType("repeatStep"); + ProcessStepBuilder repeatEchoStep = processBuilder.AddStepFromType("repeatEchoStep"); + ProcessStepBuilder echoStep = processBuilder.AddStepFromType("echoStep"); + ProcessStepBuilder emitterStep = processBuilder.AddStepFromType("emitterStep"); + ProcessStepBuilder fanInStep = processBuilder.AddStepFromType("fanInStep"); + + processBuilder + .OnInputEvent(ProcessTestsEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep)) + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep)); + + repeatStep + .OnEvent(ProcessTestsEvents.OutputReadyInternal) + .SendEventTo(new ProcessFunctionTargetBuilder(repeatEchoStep)); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.StartProcess, processBuilder), + new(repeatEchoStep.GetFunctionResultEventId(), repeatEchoStep), + ]) + .SendEventTo(new ProcessStepTargetBuilder(emitterStep, functionName: EmitterStep.DualInputPublicEventFunction, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[repeatEchoStep.GetFullEventId()] }, + { "secondInput", inputEvents[processBuilder.GetFullEventId(ProcessTestsEvents.StartProcess)] } + }; + })); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.OutputReadyInternal, repeatStep), + new(echoStep.GetFunctionResultEventId(), echoStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(emitterStep, functionName: EmitterStep.QuadInputPublicEventFunction, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[repeatStep.GetFullEventId(ProcessTestsEvents.OutputReadyInternal)] }, + { "secondInput", inputEvents[echoStep.GetFullEventId()] }, + { "fourthInput", "someFixedInputFromProcessDefinition" }, + }; + })); + + processBuilder.ListenFor().AllOf( + [ + new(ProcessTestsEvents.OutputReadyPublic, emitterStep), + new(ProcessTestsEvents.OutputReadySecondaryPublic, emitterStep), + ]) + .SendEventTo(new ProcessStepTargetBuilder(fanInStep, inputMapping: inputEvents => + { + return new() + { + { "firstInput", inputEvents[emitterStep.GetFullEventId(ProcessTestsEvents.OutputReadyPublic)] }, + { "secondInput", inputEvents[emitterStep.GetFullEventId(ProcessTestsEvents.OutputReadySecondaryPublic)] } + }; + })); + + return processBuilder; + } + /// /// Sample long sequential process, each step has a delay.
/// Input Event:
@@ -364,9 +752,21 @@ private ProcessBuilder CreateLongSequentialProcessWithFanInAsOutputStep(string n sixthNestedStep.OnEvent(EmitterStep.EventId).SendEventTo(new ProcessFunctionTargetBuilder(seventhNestedStep, functionName: EmitterStep.InternalEventFunction)); seventhNestedStep.OnEvent(EmitterStep.EventId).SendEventTo(new ProcessFunctionTargetBuilder(eighthNestedStep, functionName: EmitterStep.InternalEventFunction)); eighthNestedStep.OnEvent(EmitterStep.EventId).SendEventTo(new ProcessFunctionTargetBuilder(ninthNestedStep, functionName: EmitterStep.InternalEventFunction)); - ninthNestedStep.OnEvent(EmitterStep.EventId).SendEventTo(new ProcessFunctionTargetBuilder(tenthNestedStep, functionName: EmitterStep.DualInputPublicEventFunction, parameterName: "secondInput")); - firstNestedStep.OnEvent(EmitterStep.EventId).SendEventTo(new ProcessFunctionTargetBuilder(tenthNestedStep, functionName: EmitterStep.DualInputPublicEventFunction, parameterName: "firstInput")); + processBuilder.ListenFor().AllOf( + [ + new(EmitterStep.EventId, firstNestedStep), + new(EmitterStep.EventId, ninthNestedStep), + ]) + .SendEventTo(new ProcessStepTargetBuilder(tenthNestedStep, functionName: EmitterStep.DualInputPublicEventFunction, inputMapping: (inputEvents) => + { + // Map the input events to the parameters of the tenth step. + return new() + { + { "firstInput", inputEvents[firstNestedStep.GetFullEventId(EmitterStep.EventId)] }, + { "secondInput", inputEvents[ninthNestedStep.GetFullEventId(EmitterStep.EventId)] } + }; + })); return processBuilder; } @@ -387,11 +787,13 @@ private ProcessBuilder CreateLinearProcess(string name) var echoStep = processBuilder.AddStepFromType(id: nameof(CommonSteps.EchoStep)); var repeatStep = processBuilder.AddStepFromType(id: nameof(RepeatStep)); - processBuilder.OnInputEvent(ProcessTestsEvents.StartProcess) + processBuilder + .OnInputEvent(ProcessTestsEvents.StartProcess) .SendEventTo(new ProcessFunctionTargetBuilder(echoStep)); - echoStep.OnFunctionResult(nameof(CommonSteps.EchoStep.Echo)) - .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep, parameterName: "message")); + echoStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(repeatStep)); return processBuilder; } @@ -422,10 +824,22 @@ private ProcessBuilder CreateFanInProcess(string name) var fanInCStep = processBuilder.AddStepFromType(id: nameof(FanInStep)); processBuilder.OnInputEvent(ProcessTestsEvents.StartProcess).SendEventTo(new ProcessFunctionTargetBuilder(echoAStep)); - processBuilder.OnInputEvent(ProcessTestsEvents.StartProcess).SendEventTo(new ProcessFunctionTargetBuilder(repeatBStep, parameterName: "message")); - - echoAStep.OnFunctionResult(nameof(CommonSteps.EchoStep.Echo)).SendEventTo(new ProcessFunctionTargetBuilder(fanInCStep, parameterName: "firstInput")); - repeatBStep.OnEvent(ProcessTestsEvents.OutputReadyPublic).SendEventTo(new ProcessFunctionTargetBuilder(fanInCStep, parameterName: "secondInput")); + processBuilder.OnInputEvent(ProcessTestsEvents.StartProcess).SendEventTo(new ProcessFunctionTargetBuilder(repeatBStep)); + + processBuilder.ListenFor().AllOf( + [ + new(echoAStep.GetFunctionResultEventId(), echoAStep), + new(ProcessTestsEvents.OutputReadyPublic, repeatBStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(fanInCStep, inputMapping: (inputEvents) => + { + // Map the input events to the parameters of the fan-in step. + return new() + { + { "firstInput", inputEvents[echoAStep.GetFullEventId(echoAStep.GetFunctionResultEventId())] }, + { "secondInput", inputEvents[repeatBStep.GetFullEventId(ProcessTestsEvents.OutputReadyPublic)] } + }; + })); return processBuilder; } @@ -454,7 +868,7 @@ private ProcessBuilder CreateProcessWithError(string name) var reportStep = processBuilder.AddStepFromType("ReportStep"); processBuilder.OnInputEvent(ProcessTestsEvents.StartProcess).SendEventTo(new ProcessFunctionTargetBuilder(errorStep)); - errorStep.OnEvent(ProcessTestsEvents.ErrorStepSuccess).SendEventTo(new ProcessFunctionTargetBuilder(repeatStep, parameterName: "message")); + errorStep.OnEvent(ProcessTestsEvents.ErrorStepSuccess).SendEventTo(new ProcessFunctionTargetBuilder(repeatStep)); errorStep.OnFunctionError("ErrorWhenTrue").SendEventTo(new ProcessFunctionTargetBuilder(reportStep)); return processBuilder; @@ -464,7 +878,7 @@ private ProcessBuilder CreateProcessWithError(string name) #region Assert Utils private void AssertStepStateLastMessage(KernelProcess processInfo, string stepName, string? expectedLastMessage, int? expectedInvocationCount = null) { - KernelProcessStepInfo? stepInfo = processInfo.Steps.FirstOrDefault(s => s.State.Name == stepName); + KernelProcessStepInfo? stepInfo = processInfo.Steps.FirstOrDefault(s => s.State.StepId == stepName); Assert.NotNull(stepInfo); var outputStepResult = stepInfo.State as KernelProcessStepState; Assert.NotNull(outputStepResult?.State); @@ -474,16 +888,13 @@ private void AssertStepStateLastMessage(KernelProcess processInfo, string stepNa Assert.Equal(expectedInvocationCount.Value, outputStepResult.State.InvocationCount); } } - -#if !NET - private void AssertStepState(KernelProcess processInfo, string stepName, Predicate> predicate) where T : class, new() + private void AssertStepState(KernelProcess processInfo, string stepName, Func, bool> predicate) where T : class, new() { - KernelProcessStepInfo? stepInfo = processInfo.Steps.FirstOrDefault(s => s.State.Name == stepName); + KernelProcessStepInfo? stepInfo = processInfo.Steps.FirstOrDefault(s => s.State.StepId == stepName); Assert.NotNull(stepInfo); var outputStepResult = stepInfo.State as KernelProcessStepState; Assert.NotNull(outputStepResult?.State); Assert.True(predicate(outputStepResult)); } -#endif #endregion } diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalAgentStep.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalAgentStep.cs index 6ce3fc248b06..18a8e630abd7 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalAgentStep.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalAgentStep.cs @@ -9,6 +9,7 @@ using Microsoft.SemanticKernel.Process.Runtime; namespace Microsoft.SemanticKernel.Process; + internal class LocalAgentStep : LocalStep { private new readonly KernelProcessAgentStep _stepInfo; @@ -22,19 +23,30 @@ public LocalAgentStep(KernelProcessAgentStep stepInfo, Kernel kernel, KernelProc this._agentThread = agentThread; this._processStateManager = processStateManager; this._logger = this._kernel.LoggerFactory?.CreateLogger(this._stepInfo.InnerStepType) ?? new NullLogger(); + + this.InitializeStepInitialInputs(); } - protected override ValueTask InitializeStepAsync() + internal override KernelProcessStep CreateStepInstance() { - this._stepInstance = new KernelProcessAgentExecutorInternal(this._stepInfo, this._agentThread, this._processStateManager); - var kernelPlugin = KernelPluginFactory.CreateFromObject(this._stepInstance, pluginName: this._stepInfo.State.Name); + if (this._stepInfo is KernelProcessAgentStep agentStep) + { + return new KernelProcessAgentExecutorInternal(agentStep, this._agentThread, this._processStateManager); + } - // Load the kernel functions - foreach (KernelFunction f in kernelPlugin) + throw new InvalidOperationException($"Step {this._stepInfo.State.StepId} is not a valid agent step."); + } + + internal override void PopulateInitialInputs() + { + if (this._stepInfo is KernelProcessAgentStep agentStep) + { + this._initialInputs = this.FindInputChannels(this._functions, this._logger, this.ExternalMessageChannel, agentStep.AgentDefinition); + } + else { - this._functions.Add(f.Name, f); + throw new InvalidOperationException($"Step {this._stepInfo.State.StepId} is not a valid agent step."); } - return default; } internal override async Task HandleMessageAsync(ProcessMessage message) @@ -65,7 +77,7 @@ internal override async Task HandleMessageAsync(ProcessMessage message) this._eventNamespace, sourceId: $"{targetFunction}.OnResult", eventVisibility: KernelProcessEventVisibility.Public, - writtenToThread: this._agentThread.ThreadId)); // TODO: This is keeping track of the thread the message has been written to, clean it up, name it better, etc. + writtenToThread: this._agentThread.ThreadId)); // TODO: This is keeping track of the thread the message has been written to, clean it up, name it better, etc. } catch (Exception ex) { diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalEdgeGroupProcessor.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalEdgeGroupProcessor.cs index 887a32511421..1503a3a842a2 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalEdgeGroupProcessor.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalEdgeGroupProcessor.cs @@ -7,10 +7,11 @@ namespace Microsoft.SemanticKernel; internal class LocalEdgeGroupProcessor { private readonly KernelProcessEdgeGroup _edgeGroup; - private readonly Dictionary _messageData = []; private HashSet _requiredMessages = new(); private HashSet _absentMessages = new(); + public Dictionary MessageData { get; private set; } = []; + public LocalEdgeGroupProcessor(KernelProcessEdgeGroup edgeGroup) { Verify.NotNull(edgeGroup, nameof(edgeGroup)); @@ -19,6 +20,30 @@ public LocalEdgeGroupProcessor(KernelProcessEdgeGroup edgeGroup) this.InitializeEventTracking(); } + public void ClearMessageData() + { + this.MessageData.Clear(); + this.InitializeEventTracking(); + } + + public bool RehydrateMessageData(Dictionary cachedMessageData) + { + if (cachedMessageData == null || cachedMessageData.Count == 0) + { + return false; + } + + // Add check to ensure message data values have supported types + + foreach (var message in cachedMessageData) + { + this.MessageData[message.Key] = message.Value; + } + this._absentMessages.RemoveWhere(message => cachedMessageData.ContainsKey(message)); + + return true; + } + public bool TryGetResult(ProcessMessage message, out Dictionary? result) { string messageKey = this.GetKeyForMessageSource(message); @@ -27,13 +52,22 @@ public bool TryGetResult(ProcessMessage message, out Dictionary throw new KernelException($"Message {messageKey} is not expected for edge group {this._edgeGroup.GroupId}."); } - this._messageData[messageKey] = (message.TargetEventData as KernelProcessEventData)!.ToObject(); + if (message.TargetEventData is KernelProcessEventData processEventData) + { + // used by events from steps + this.MessageData[messageKey] = processEventData.ToObject(); + } + else + { + // used by events that are process input events + this.MessageData[messageKey] = message.TargetEventData; + } this._absentMessages.Remove(messageKey); if (this._absentMessages.Count == 0) { // We have received all required events so forward them to the target - result = (Dictionary?)this._edgeGroup.InputMapping(this._messageData); + result = (Dictionary?)this._edgeGroup.InputMapping(this.MessageData); // TODO: Reset state according to configured logic i.e. reset after first message or after all messages are received. this.InitializeEventTracking(); diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessContext.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessContext.cs index f4ee96daac1a..ea3712210f99 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessContext.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessContext.cs @@ -1,4 +1,5 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; using System.Threading.Tasks; using Microsoft.SemanticKernel.Process; @@ -12,27 +13,33 @@ public sealed class LocalKernelProcessContext : KernelProcessContext, System.IAs private readonly LocalProcess _localProcess; private readonly Kernel _kernel; - internal LocalKernelProcessContext(KernelProcess process, Kernel kernel, ProcessEventProxy? eventProxy = null, IExternalKernelProcessMessageChannel? externalMessageChannel = null) + private readonly ProcessStorageManager? _storageConnector; + + internal LocalKernelProcessContext(KernelProcess process, Kernel kernel, ProcessEventProxy? eventProxy = null, IExternalKernelProcessMessageChannel? externalMessageChannel = null, IProcessStorageConnector? storageConnector = null, string? instanceId = null) { Verify.NotNull(process, nameof(process)); Verify.NotNull(kernel, nameof(kernel)); - Verify.NotNullOrWhiteSpace(process.State?.Name); + Verify.NotNullOrWhiteSpace(process.State?.StepId); + + if (storageConnector != null) + { + this._storageConnector = new(storageConnector); + } this._kernel = kernel; - this._localProcess = new LocalProcess(process, kernel) + this._localProcess = new LocalProcess(process, kernel, instanceId) { EventProxy = eventProxy, ExternalMessageChannel = externalMessageChannel, + StorageManager = this._storageConnector, }; } internal Task StartWithEventAsync(KernelProcessEvent initialEvent, Kernel? kernel = null) => this._localProcess.RunOnceAsync(initialEvent, kernel); - //internal RunUntilEndAsync(KernelProcessEvent initialEvent, Kernel? kernel = null, TimeSpan? timeout = null) - //{ - - //} + internal Task StartWithEventKeepRunning(KernelProcessEvent initialEvent, Kernel? kernel = null) => + this._localProcess.RunUntilEndAsync(initialEvent, kernel); /// /// Sends a message to the process. @@ -70,4 +77,14 @@ public async ValueTask DisposeAsync() /// public override Task GetProcessIdAsync() => Task.FromResult(this._localProcess.Id); + + /// + /// Read the step states in from the process. + /// + /// + /// + public override Task> GetStepStatesAsync() + { + throw new System.NotImplementedException(); + } } diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessFactory.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessFactory.cs index 125f22dcface..9f5c10e5e57e 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessFactory.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalKernelProcessFactory.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Collections.Generic; using System.Threading.Tasks; namespace Microsoft.SemanticKernel; @@ -16,17 +17,47 @@ public static class LocalKernelProcessFactory /// Required: The to start running. /// Required: An instance of /// Required: The initial event to start the process. + /// Optional: id to be assigined to the running process, if null it will be assigned during runtime /// Optional: an instance of . + /// Optional: an instance of . /// An instance of that can be used to interrogate or stop the running process. - public static async Task StartAsync(this KernelProcess process, Kernel kernel, KernelProcessEvent initialEvent, IExternalKernelProcessMessageChannel? externalMessageChannel = null) + public static async Task StartAsync( + this KernelProcess process, + Kernel kernel, + KernelProcessEvent initialEvent, + string? processId = null, + IExternalKernelProcessMessageChannel? externalMessageChannel = null, + IProcessStorageConnector? storageConnector = null) { Verify.NotNull(initialEvent, nameof(initialEvent)); - LocalKernelProcessContext processContext = new(process, kernel, null, externalMessageChannel); + LocalKernelProcessContext processContext = new(process, kernel, null, externalMessageChannel, storageConnector, instanceId: processId); await processContext.StartWithEventAsync(initialEvent).ConfigureAwait(false); return processContext; } + /// + /// Create Local Kernel Process Context. + /// + /// + /// + /// + /// + /// + /// + public static LocalKernelProcessContext CreateContext( + this KernelProcess process, + Kernel kernel, + //KernelProcessEvent initialEvent, + string? processId = null, + IExternalKernelProcessMessageChannel? externalMessageChannel = null, + IProcessStorageConnector? storageConnector = null) + { + LocalKernelProcessContext processContext = new(process, kernel, null, externalMessageChannel, storageConnector, instanceId: processId); + + return processContext; + } + /// /// Starts the specified process and runs it to completion. /// @@ -45,4 +76,44 @@ public static async Task RunToEndAsync(this KernelPro await processContext.StartWithEventAsync(initialEvent).ConfigureAwait(false); return processContext; } + + /// + /// Starts a specific process using registered processes + /// + /// Required: An instance of + /// Required: dictionary with registered processes + /// Required: key of the process in registered processes + /// Required: id to be assigined to the running process, if null it will be assigned during runtime + /// Required: The initial event to start the process. + /// Optional: an instance of . + /// Optional: an instance of . + /// + /// + public static async Task StartAsync( + Kernel kernel, + IReadOnlyDictionary registeredProcesses, + string processKey, + string? processId, + KernelProcessEvent initialEvent, + IExternalKernelProcessMessageChannel? externalMessageChannel = null, + IProcessStorageConnector? storageConnector = null) + { + Verify.NotNullOrWhiteSpace(processKey, nameof(processKey)); + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + Verify.NotNull(initialEvent, nameof(initialEvent)); + + if (!registeredProcesses.TryGetValue(processKey, out KernelProcess? process) || process is null) + { + throw new ArgumentException($"The process with key '{processKey}' is not registered."); + } + + if (string.IsNullOrWhiteSpace(process.State.StepId)) + { + process = process with { State = process.State with { StepId = processKey } }; + } + + LocalKernelProcessContext processContext = new(process, kernel, null, externalMessageChannel, storageConnector, processId); + await processContext.StartWithEventAsync(initialEvent).ConfigureAwait(false); + return processContext; + } } diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalMap.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalMap.cs index a46d7f3a9663..706b8b3032c3 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalMap.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalMap.cs @@ -27,7 +27,7 @@ internal LocalMap(KernelProcessMap map, Kernel kernel) : base(map, kernel) { this._map = map; - this._logger = this._kernel.LoggerFactory?.CreateLogger(this._map.State.Name) ?? new NullLogger(); + this._logger = this._kernel.LoggerFactory?.CreateLogger(this._map.State.StepId) ?? new NullLogger(); this._mapEvents = [.. map.Edges.Keys.Select(key => key.Split(ProcessConstants.EventIdSeparator).Last())]; } diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalProcess.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalProcess.cs index 77fa480c3b4e..bc1e36fd55a1 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalProcess.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalProcess.cs @@ -23,7 +23,7 @@ internal sealed class LocalProcess : LocalStep, System.IAsyncDisposable { private readonly JoinableTaskFactory _joinableTaskFactory; private readonly JoinableTaskContext _joinableTaskContext; - private readonly Channel _externalEventChannel; + private readonly ObservableChannel _externalEventChannel; private new readonly Lazy _initializeTask; private readonly Dictionary _threads = []; @@ -31,31 +31,43 @@ internal sealed class LocalProcess : LocalStep, System.IAsyncDisposable internal readonly List _steps = []; internal readonly KernelProcess _process; + internal KernelProcess Process + { + // Special get to ensure returning most updated process data + get => this._process with { State = this._stepState, Steps = this._steps.Select(step => step._stepInfo).ToList() }; + } + private readonly ILogger _logger; private JoinableTask? _processTask; private CancellationTokenSource? _processCancelSource; private ProcessStateManager? _processStateManager; + private readonly LocalUserStateStore _userStateStore; + + private List _runningStepIds = []; /// /// Initializes a new instance of the class. /// /// The instance. /// An instance of - internal LocalProcess(KernelProcess process, Kernel kernel) - : base(process, kernel) + /// id to be used for LocalProcess as unique identifier + internal LocalProcess(KernelProcess process, Kernel kernel, string? instanceId = null) + : base(process, kernel, instanceId: instanceId) { Verify.NotNull(process.Steps); this._stepsInfos = new List(process.Steps); this._process = process; this._initializeTask = new Lazy(this.InitializeProcessAsync); - this._externalEventChannel = Channel.CreateUnbounded(); + this._externalEventChannel = new ObservableChannel(Channel.CreateUnbounded()); this._joinableTaskContext = new JoinableTaskContext(); this._joinableTaskFactory = new JoinableTaskFactory(this._joinableTaskContext); this._logger = this._kernel.LoggerFactory?.CreateLogger(this.Name) ?? new NullLogger(); // if parent id is null this is the root process this.RootProcessId = this.ParentProcessId == null ? this.Id : null; + this._stepState.ParentId = this.ParentProcessId; + this._userStateStore = new LocalUserStateStore(); } /// @@ -63,6 +75,8 @@ internal LocalProcess(KernelProcess process, Kernel kernel) /// internal string? RootProcessId { get; init; } + internal new ProcessStorageManager? StorageManager { get; init; } + /// /// Starts the process with an initial event and an optional kernel. /// @@ -92,7 +106,7 @@ internal async Task RunOnceAsync(KernelProcessEvent processEvent, Kernel? kernel Verify.NotNullOrWhiteSpace(processEvent.Id, $"{nameof(processEvent)}.{nameof(KernelProcessEvent.Id)}"); await Task.Yield(); // Ensure that the process has an opportunity to run in a different synchronization context. - await this._externalEventChannel.Writer.WriteAsync(processEvent).ConfigureAwait(false); + await this._externalEventChannel.WriteAsync(processEvent).ConfigureAwait(false); await this.StartAsync(kernel, keepAlive: false).ConfigureAwait(false); await this._processTask!.JoinAsync().ConfigureAwait(false); } @@ -111,9 +125,33 @@ internal async Task RunUntilEndAsync(KernelProcessEvent processEvent, Kernel? ke Verify.NotNullOrWhiteSpace(processEvent.Id, $"{nameof(processEvent)}.{nameof(KernelProcessEvent.Id)}"); await Task.Yield(); // Ensure that the process has an opportunity to run in a different synchronization context. - await this._externalEventChannel.Writer.WriteAsync(processEvent).ConfigureAwait(false); + await this._externalEventChannel.WriteAsync(processEvent).ConfigureAwait(false); await this.StartAsync(kernel, keepAlive: true).ConfigureAwait(false); - await this._processTask!.JoinAsync().ConfigureAwait(false); + + // If a timeout is specified, enforce it + if (timeout != null && timeout.HasValue) + { + using (var cts = new CancellationTokenSource(timeout.Value)) + { + var processTask = this._processTask!.JoinAsync(); + var timeoutTask = Task.Delay(Timeout.Infinite, cts.Token); // Task.Delay with cancellation + + var completedTask = await Task.WhenAny(processTask, timeoutTask).ConfigureAwait(false); + + if (completedTask == timeoutTask) + { + throw new TimeoutException($"The operation did not complete within the allotted timeout of {timeout.Value}."); + } + + // Ensure the process task completes (or re-throw exceptions if it failed) + await processTask.ConfigureAwait(false); + } + } + else + { + // No timeout, just wait for the process to finish + await this._processTask!.JoinAsync().ConfigureAwait(false); + } } /// @@ -154,7 +192,12 @@ internal async Task StopAsync() internal async Task SendMessageAsync(KernelProcessEvent processEvent, Kernel? kernel = null) { Verify.NotNull(processEvent, nameof(processEvent)); - await this._externalEventChannel.Writer.WriteAsync(processEvent).AsTask().ConfigureAwait(false); + await this._externalEventChannel.WriteAsync(processEvent).AsTask().ConfigureAwait(false); + + if (this._processCancelSource != null && this.StorageManager != null) + { + await this.StorageManager.SaveProcessEventsAsync(this.Process, this._externalEventChannel.GetChannelSnapshot()).ConfigureAwait(false); + } // make sure the process is running in case it was already cancelled if (this._processCancelSource == null) @@ -169,6 +212,12 @@ internal async Task SendMessageAsync(KernelProcessEvent processEvent, Kernel? ke /// An instance of internal Task GetProcessInfoAsync() => this.ToKernelProcessAsync(); + internal override async Task SaveStepStateAsync() + { + // To be replaced with logic to save process state + await this.SaveProcessInfoAsync().ConfigureAwait(false); + } + /// /// Handles a that has been sent to the process. This happens only in the case /// of a process (this one) running as a step within another process (this one's parent). In this case the @@ -197,6 +246,78 @@ internal override async Task HandleMessageAsync(ProcessMessage message) } #region Private Methods + private string GetChildStepId() + { + return $"{this.Id}_{Guid.NewGuid()}"; + } + + /// + /// Fetches process data from storage and children data if child is a step. + /// For subprocesses, subprocess children data is fetched by the subprocess itself when it initializes. + /// + /// + private async Task FetchSavedProcessDataAsync() + { + if (this.StorageManager != null) + { + await this.StorageManager.FetchProcessDataAsync(this.Process).ConfigureAwait(false); + } + } + + private async Task FetchProcessChildrenDataAsync() + { + if (this.StorageManager != null) + { + foreach (var step in this._steps) + { + if (step is not LocalProcess) + { + await this.StorageManager.FetchStepDataAsync(step._stepInfo).ConfigureAwait(false); + } + } + } + } + + private async Task SaveProcessInfoAsync() + { + if (this.StorageManager != null) + { + await this.StorageManager.SaveProcessInfoAsync(this.Process).ConfigureAwait(false); + } + } + + private async Task SaveProcessDataAsync() + { + if (this.StorageManager != null) + { + await this.StorageManager.SaveProcessInfoAsync(this.Process).ConfigureAwait(false); + await this.StorageManager.SaveProcessStateAsync(this.Process, this._userStateStore.UserState).ConfigureAwait(false); + await this.StorageManager.SaveProcessEventsAsync(this.Process, this._externalEventChannel.GetChannelSnapshot()).ConfigureAwait(false); + } + } + + protected async Task SaveProcessAndChildrenDataToStorageAsync() + { + if (this.StorageManager != null) + { + await this.StorageManager.SaveProcessDataToStorageAsync(this.Process).ConfigureAwait(false); + + // Filtering saving only steps that ran in last superstep execution loop + var executedSteps = this._steps.Where(step => this._runningStepIds.Contains(step.Id)) ?? []; + + foreach (var step in executedSteps) + { + if (step is not LocalProcess subprocessStep) + { + // Local Process when they run they do their own checkpointing, no need to do it again. + await this.StorageManager.SaveStepDataToStorageAsync(step.StepInfo).ConfigureAwait(false); + } + } + this._runningStepIds = []; + + // TODO: Potentially call to "Runtime -> WriteStateAsync() with actorId/processId should be called here + } + } /// /// Loads the process and initializes the steps. Once this is complete the process can be started. @@ -206,6 +327,38 @@ private async ValueTask InitializeProcessAsync() { // Initialize the input and output edges for the process this._outputEdges = this._process.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToList()); + Dictionary processInfoInstanceMap = []; + + if (this.StorageManager != null) + { + await this.StorageManager.InitializeAsync().ConfigureAwait(false); + await this.FetchSavedProcessDataAsync().ConfigureAwait(false); + + // Trying to restore step running ids instances from storage before creation of steps + var processInfo = await this.StorageManager.GetProcessInfoAsync(this.Process).ConfigureAwait(false); + if (processInfo != null && processInfo.Steps.Count > 0) + { + processInfoInstanceMap = processInfo.Steps; + } + + // Trying to restore process state variables from storage + var processStateVariables = await this.StorageManager.GetProcessStateVariablesAsync(this.Process).ConfigureAwait(false); + if (processStateVariables != null) + { + // Is UserStateStore used across subprocesses? or is it scoped to the process and children steps only? + this._userStateStore.ResetUserState(processStateVariables!); + } + + // TODO: Need a better implementation of the external event channel instead of the workaround with ObservableChannel. + // Trying to restore process events from storage + //var pendingExternalEvents = await this.StorageManager.GetProcessExternalEventsAsync(this.Process).ConfigureAwait(false); + //if (pendingExternalEvents != null) + //{ + // this._externalEventChannel = new ObservableChannel(Channel.CreateUnbounded()); + //} + } + + bool usingExistingProcessInstances = processInfoInstanceMap.Count > 0; // TODO: Pull user state from persisted state on resume. this._processStateManager = new ProcessStateManager(this._process.UserStateType, null); @@ -247,44 +400,49 @@ private async ValueTask InitializeProcessAsync() LocalStep? localStep = null; // The current step should already have a name. - Verify.NotNull(step.State?.Name); + Verify.NotNull(step.State?.StepId); - if (step is KernelProcess processStep) + // Assign id to kernelStepInfo if any before creation of Local components + if (!processInfoInstanceMap.TryGetValue(step.State.StepId, out string? stepId) && stepId == null) { - // The process will only have an Id if its already been executed. - if (string.IsNullOrWhiteSpace(processStep.State.Id)) - { - processStep = processStep with { State = processStep.State with { Id = Guid.NewGuid().ToString() } }; - } + stepId = this.GetChildStepId(); + } + KernelProcessStepInfo stepInfo = step.CloneWithIdAndEdges(stepId, this._logger); + + if (stepInfo is KernelProcess processStep) + { + // Subprocess should be created with an assigned id, only root process can be without the id + Verify.NotNullOrWhiteSpace(processStep.State.RunId); localStep = - new LocalProcess(processStep, this._kernel) + new LocalProcess(processStep, this._kernel, stepId) { ParentProcessId = this.Id, RootProcessId = this.RootProcessId, EventProxy = this.EventProxy, ExternalMessageChannel = this.ExternalMessageChannel, + StorageManager = this.StorageManager, }; } - else if (step is KernelProcessMap mapStep) + else if (stepInfo is KernelProcessMap mapStep) { + mapStep = mapStep with { Operation = mapStep.Operation with { State = mapStep.Operation.State with { RunId = mapStep.Operation.State.StepId } } }; localStep = new LocalMap(mapStep, this._kernel) { ParentProcessId = this.Id, }; } - else if (step is KernelProcessProxy proxyStep) + else if (stepInfo is KernelProcessProxy proxyStep) { localStep = - new LocalProxy(proxyStep, this._kernel) + new LocalProxy(proxyStep, this._kernel, this.ExternalMessageChannel) { ParentProcessId = this.RootProcessId, EventProxy = this.EventProxy, - ExternalMessageChannel = this.ExternalMessageChannel }; } - else if (step is KernelProcessAgentStep agentStep) + else if (stepInfo is KernelProcessAgentStep agentStep) { if (!this._threads.TryGetValue(agentStep.ThreadName, out KernelProcessAgentThread? thread) || thread is null) { @@ -296,18 +454,28 @@ private async ValueTask InitializeProcessAsync() else { // The current step should already have an Id. - Verify.NotNull(step.State?.Id); + Verify.NotNull(stepInfo.State?.RunId); + // TODO: piping this._userStateStore to LocalStep temporarily since these changes don't include yet LocalDelegateStep + // LocalDelegateStep should be the only one with access to this._userStateStore localStep = - new LocalStep(step, this._kernel) + new LocalStep(stepInfo, this._kernel, parentProcessId: this.Id, userStateStore: this._userStateStore) { - ParentProcessId = this.Id, - EventProxy = this.EventProxy + EventProxy = this.EventProxy, + StorageManager = this.StorageManager, }; } this._steps.Add(localStep); } + // Now that children ids are fetched from storage if any + if (usingExistingProcessInstances) + { + await this.FetchProcessChildrenDataAsync().ConfigureAwait(false); + } + + // Process steps local instances have been created, saving process info + await this.SaveProcessInfoAsync().ConfigureAwait(false); } /// @@ -329,7 +497,7 @@ private async Task Internal_ExecuteAsync(Kernel? kernel = null, int maxSuperstep try { - // + // await this.EnqueueOnEnterMessagesAsync(messageChannel).ConfigureAwait(false); // Run the Pregel algorithm until there are no more messages being sent. @@ -352,7 +520,7 @@ private async Task Internal_ExecuteAsync(Kernel? kernel = null, int maxSuperstep // If there are no messages to process, wait for an external event. if (messagesToProcess.Length == 0) { - if (!keepAlive || !await this._externalEventChannel.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) + if (!keepAlive || !await this._externalEventChannel.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) { this._processCancelSource?.Cancel(); break; @@ -360,6 +528,8 @@ private async Task Internal_ExecuteAsync(Kernel? kernel = null, int maxSuperstep } List messageTasks = []; + this._runningStepIds = []; + foreach (var message in messagesToProcess) { // Check for end condition @@ -369,14 +539,24 @@ private async Task Internal_ExecuteAsync(Kernel? kernel = null, int maxSuperstep break; } - var destinationStep = this._steps.First(v => v.Id == message.DestinationId); + var destinationStep = this._steps.First(v => v.Name == message.DestinationId); - // Send a message to the step - messageTasks.Add(destinationStep.HandleMessageAsync(message)); - finalStep = destinationStep; + if (destinationStep != null) + { + this._runningStepIds.Add(destinationStep.Id); + // Send a message to the step + messageTasks.Add(destinationStep.HandleMessageAsync(message)); + finalStep = destinationStep; + } } await Task.WhenAll(messageTasks).ConfigureAwait(false); + + // All steps have executed saving process data: state, events, etc + await this.SaveProcessDataAsync().ConfigureAwait(false); + + // Now saving checkpoint of process to storage + await this.SaveProcessAndChildrenDataToStorageAsync().ConfigureAwait(false); } } catch (Exception ex) @@ -399,12 +579,14 @@ private async Task EnqueueEdgesAsync(IEnumerable edges, Queue List defaultConditionedEdges = []; foreach (var edge in edges) { - if (edge.Condition.DeclarativeDefinition?.Equals(ProcessConstants.Declarative.DefaultCondition, StringComparison.OrdinalIgnoreCase) ?? false) + // Default conditions are processed at the end if no other conditions are met. + if (edge.Condition.IsDefault()) { defaultConditionedEdges.Add(edge); continue; } + // Check if the condition is met for this edge, if not skip it. bool isConditionMet = await edge.Condition.Callback(processEvent.ToKernelProcessEvent(), this._processStateManager?.GetState()).ConfigureAwait(false); if (!isConditionMet) { @@ -421,6 +603,7 @@ private async Task EnqueueEdgesAsync(IEnumerable edges, Queue await (this._processStateManager.ReduceAsync((stateType, state) => { + // this should all be contained within a callback var stateJson = JsonDocument.Parse(JsonSerializer.Serialize(state)); stateJson = JMESUpdate.UpdateState(stateJson, stateTarget.VariableUpdate.Path, stateTarget.VariableUpdate.Operation, stateTarget.VariableUpdate.Value); return Task.FromResult(stateJson.Deserialize(stateType)); @@ -428,7 +611,7 @@ private async Task EnqueueEdgesAsync(IEnumerable edges, Queue } else if (edge.OutputTarget is KernelProcessEmitTarget emitTarget) { - // Emit target from process + // Emit target from the step } else if (edge.OutputTarget is KernelProcessFunctionTarget functionTarget) { @@ -453,7 +636,7 @@ private async Task EnqueueEdgesAsync(IEnumerable edges, Queue { foreach (KernelProcessEdge edge in defaultConditionedEdges) { - ProcessMessage message = ProcessMessageFactory.CreateFromEdge(edge, this._process.State.Id!, null, null); + ProcessMessage message = ProcessMessageFactory.CreateFromEdge(edge, this._process.State.RunId!, null, null); messageChannel.Enqueue(message); // TODO: Handle state here as well @@ -482,7 +665,7 @@ private async Task EnqueueOnEnterMessagesAsync(Queue messageChan var processEvent = new ProcessEvent { Namespace = this.Name, - SourceId = this._process.State.Id!, + SourceId = this._process.State.RunId!, Data = null, Visibility = KernelProcessEventVisibility.Internal }; @@ -498,7 +681,7 @@ private async Task EnqueueOnEnterMessagesAsync(Queue messageChan /// The message channel where messages should be enqueued. private void EnqueueExternalMessages(Queue messageChannel) { - while (this._externalEventChannel.Reader.TryRead(out var externalEvent)) + while (this._externalEventChannel.TryRead(out var externalEvent) && externalEvent != null) { if (this._outputEdges.TryGetValue(externalEvent.Id, out List? edges) && edges is not null) { @@ -529,6 +712,20 @@ private async Task EnqueueStepMessagesAsync(LocalStep step, Queue /// an instance of /// An instance of - internal LocalProxy(KernelProcessProxy proxy, Kernel kernel) + /// An instance of + internal LocalProxy(KernelProcessProxy proxy, Kernel kernel, IExternalKernelProcessMessageChannel? externalMessageChannel) : base(proxy, kernel) { this._proxy = proxy; - this._logger = this._kernel.LoggerFactory?.CreateLogger(this._proxy.State.Name) ?? new NullLogger(); + this._logger = this._kernel.LoggerFactory?.CreateLogger(this._proxy.State.StepId) ?? new NullLogger(); + this.ExternalMessageChannel = externalMessageChannel; + + this.InitializeStepInitialInputs(); + } + + internal override void PopulateInitialInputs() + { + this._initialInputs = this.FindInputChannels(this._functions, this._logger, this.ExternalMessageChannel); } internal override void AssignStepFunctionParameterValues(ProcessMessage message) diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalStep.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalStep.cs index 286ab272d3d7..bf848fd02294 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/LocalStep.cs +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalStep.cs @@ -7,6 +7,7 @@ using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.SemanticKernel.Process; using Microsoft.SemanticKernel.Process.Internal; using Microsoft.SemanticKernel.Process.Runtime; @@ -15,7 +16,7 @@ namespace Microsoft.SemanticKernel; /// /// Represents a step in a process that is running in-process. /// -internal class LocalStep : IKernelProcessMessageChannel +internal class LocalStep : IKernelProcessMessageChannel, IKernelProcessUserStateStore { private readonly Queue _outgoingEventQueue = new(); protected readonly Lazy _initializeTask; @@ -33,6 +34,7 @@ internal class LocalStep : IKernelProcessMessageChannel internal KernelProcessStep? _stepInstance = null; internal readonly KernelProcessStepInfo _stepInfo; internal readonly string _eventNamespace; + private readonly LocalUserStateStore? _userStateStore; /// /// Represents a step in a process that is running in-process. @@ -40,30 +42,71 @@ internal class LocalStep : IKernelProcessMessageChannel /// An instance of /// Required. An instance of . /// Optional. The Id of the parent process if one exists. - public LocalStep(KernelProcessStepInfo stepInfo, Kernel kernel, string? parentProcessId = null) + /// Optional: Id of the process if given + /// + public LocalStep(KernelProcessStepInfo stepInfo, Kernel kernel, string? parentProcessId = null, string? instanceId = null, LocalUserStateStore? userStateStore = null) { Verify.NotNull(kernel, nameof(kernel)); Verify.NotNull(stepInfo, nameof(stepInfo)); - // This special handling will be removed with the refactoring of KernelProcessState - if (string.IsNullOrEmpty(stepInfo.State.Id) && stepInfo is KernelProcess) + if (stepInfo is KernelProcess) { - stepInfo = stepInfo with { State = stepInfo.State with { Id = Guid.NewGuid().ToString() } }; + // Only KernelProcess can have a null Id if it is the root process + stepInfo = stepInfo with { State = stepInfo.State with { RunId = instanceId ?? Guid.NewGuid().ToString() } }; } + // For any step that is not a process, step id must already be assigned from parent process in the step state + Verify.NotNullOrWhiteSpace(stepInfo.State.RunId); - Verify.NotNull(stepInfo.State.Id); - - this.ParentProcessId = parentProcessId; this._kernel = kernel; this._stepInfo = stepInfo; - this._stepState = stepInfo.State; - this._initializeTask = new Lazy(this.InitializeStepAsync); this._logger = this._kernel.LoggerFactory?.CreateLogger(this._stepInfo.InnerStepType) ?? new NullLogger(); + this._userStateStore = userStateStore; + + if (stepInfo is not KernelProcess and not KernelProcessMap and not KernelProcessProxy and not KernelProcessAgentStep) + { + this.InitializeStepInitialInputs(); + } + + Verify.NotNull(stepInfo.State.RunId); + + this.ParentProcessId = parentProcessId; + this._stepState = stepInfo.State with { ParentId = parentProcessId }; + this._initializeTask = new Lazy(this.InitializeStepAsync); this._outputEdges = this._stepInfo.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToList()); this._eventNamespace = this.Id; this._edgeGroupProcessors = this._stepInfo.IncomingEdgeGroups?.ToDictionary(kvp => kvp.Key, kvp => new LocalEdgeGroupProcessor(kvp.Value)) ?? []; } + internal void InitializeStepInitialInputs() + { + // Instantiate an instance of the inner step object + this._stepInstance = this.CreateStepInstance(); + + var kernelPlugin = KernelPluginFactory.CreateFromObject(this._stepInstance, pluginName: this._stepInfo.State.StepId); + + // Load the kernel functions + foreach (KernelFunction f in kernelPlugin) + { + this._functions.Add(f.Name, f); + } + + // Initialize the input channels + this.PopulateInitialInputs(); + } + + internal virtual KernelProcessStep CreateStepInstance() + { + var stepInstance = (KernelProcessStep)ActivatorUtilities.CreateInstance(this._kernel.Services, this._stepInfo.InnerStepType); + typeof(KernelProcessStep).GetProperty(nameof(KernelProcessStep.StepName))?.SetValue(stepInstance, this._stepInfo.State.StepId); + + return stepInstance; + } + + internal virtual void PopulateInitialInputs() + { + this._initialInputs = this.FindInputChannels(this._functions, this._logger, this.ExternalMessageChannel, stateStore: this._userStateStore); + } + /// /// The Id of the parent process if one exists. /// @@ -72,12 +115,12 @@ public LocalStep(KernelProcessStepInfo stepInfo, Kernel kernel, string? parentPr /// /// The name of the step. /// - internal string Name => this._stepInfo.State.Name!; + internal string Name => this._stepInfo.State.StepId!; /// /// The Id of the step. /// - internal string Id => this._stepInfo.State.Id!; + internal string Id => this._stepInfo.State.RunId!; /// /// An event proxy that can be used to intercept events emitted by the step. @@ -86,6 +129,13 @@ public LocalStep(KernelProcessStepInfo stepInfo, Kernel kernel, string? parentPr internal IExternalKernelProcessMessageChannel? ExternalMessageChannel { get; init; } + internal IProcessStepStorageOperations? StorageManager { get; init; } + + internal KernelProcessStepInfo StepInfo + { + get => this._stepInfo with { State = this._stepState }; + } + /// /// Retrieves all events that have been emitted by this step in the previous superstep. /// @@ -198,16 +248,26 @@ internal virtual async Task HandleMessageAsync(ProcessMessage message) if (!edgeGroupProcessor.TryGetResult(message, out Dictionary? result)) { - // The edge group processor has not received all required messages yet. + await this.SaveStepEventsAsync().ConfigureAwait(false); return; } + // Saving values with updated new edge value + await this.SaveStepEventsAsync().ConfigureAwait(false); // The edge group processor has received all required messages and has produced a result. message = message with { Values = result ?? [] }; + + // Add the message values to the inputs for the function + this.AssignStepFunctionParameterValues(message); } + else + { + // Add the message values to the inputs for the function + this.AssignStepFunctionParameterValues(message); - // Add the message values to the inputs for the function - this.AssignStepFunctionParameterValues(message); + // TODO: Add saving last message received when no edge groups are used + //await this.SaveStepEventsAsync(message).ConfigureAwait(false); + } // If we're still waiting for inputs on all of our functions then don't do anything. List invocableFunctions = this._inputs.Where(i => i.Value != null && i.Value.All(v => v.Value != null)).Select(i => i.Key).ToList(); @@ -264,10 +324,45 @@ internal virtual async Task HandleMessageAsync(ProcessMessage message) { // Reset the inputs for the function that was just executed this._inputs[targetFunction] = new(this._initialInputs[targetFunction] ?? []); + + if (!string.IsNullOrEmpty(message.GroupId) && this._edgeGroupProcessors != null) + { + // Only clearing out edge processor with most recent group id received + if (this._edgeGroupProcessors.TryGetValue(message.GroupId, out LocalEdgeGroupProcessor? edgeGroupProcessor) && edgeGroupProcessor != null) + { + edgeGroupProcessor.ClearMessageData(); + } + } + + await this.SaveStepStateAsync().ConfigureAwait(false); + await this.SaveStepEventsAsync().ConfigureAwait(false); } #pragma warning restore CA1031 // Do not catch general exception types } + private async Task TryRestoreCachedUnprocessedInputValuesAsync() + { + if (this._initialInputs == null) + { + throw new KernelException("Initial Inputs have not been initialize, cannot initialize step properly"); + } + + if (this.StorageManager != null) + { + var stepEventData = await this.StorageManager.GetStepEventsAsync(this.StepInfo).ConfigureAwait(false); + if (this._edgeGroupProcessors != null && stepEventData?.EdgesData != null) + { + foreach (var edgeGroup in this._edgeGroupProcessors) + { + if (stepEventData.EdgesData.TryGetValue(edgeGroup.Key, out Dictionary? edgeGroupData) && edgeGroupData != null) + { + edgeGroup.Value.RehydrateMessageData(edgeGroupData.ToDictionary(edgeGroupData => edgeGroupData.Key, edgeGroupData => edgeGroupData.Value?.ToObject())); + } + } + } + } + } + /// /// Initializes the step with the provided step information. /// @@ -275,31 +370,30 @@ internal virtual async Task HandleMessageAsync(ProcessMessage message) /// protected virtual async ValueTask InitializeStepAsync() { - // Instantiate an instance of the inner step object - this._stepInstance = (KernelProcessStep)ActivatorUtilities.CreateInstance(this._kernel.Services, this._stepInfo.InnerStepType); - var kernelPlugin = KernelPluginFactory.CreateFromObject(this._stepInstance, pluginName: this._stepInfo.State.Name); - - // Load the kernel functions - foreach (KernelFunction f in kernelPlugin) + if (this._initialInputs == null || this._stepInstance == null) { - this._functions.Add(f.Name, f); + throw new KernelException("Initial Inputs have not been initialize, cannot initialize step properly"); } - // Initialize the input channels - if (this._stepInfo is KernelProcessAgentStep agentStep) + // Populating step function inputs + this._inputs = this._initialInputs.ToDictionary(kvp => kvp.Key, kvp => kvp.Value?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)); + + // Activate the step with user-defined state if needed + Type stateType = this._stepInfo.InnerStepType.ExtractStateType(out Type? userStateType, this._logger); + KernelProcessStepState? stateObject = null; + + if (this.StorageManager != null) { - this._initialInputs = this.FindInputChannels(this._functions, this._logger, this.ExternalMessageChannel, agentStep.AgentDefinition); + stateObject = await this.StorageManager.GetStepStateAsync(this.StepInfo).ConfigureAwait(false); + await this.TryRestoreCachedUnprocessedInputValuesAsync().ConfigureAwait(false); } - else + + if (stateObject == null) { - this._initialInputs = this.FindInputChannels(this._functions, this._logger, this.ExternalMessageChannel); + // no previous state in storage found, try using the default state instead + stateObject = this._stepInfo.State; } - this._inputs = this._initialInputs.ToDictionary(kvp => kvp.Key, kvp => kvp.Value?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)); - - // Activate the step with user-defined state if needed - Type stateType = this._stepInfo.InnerStepType.ExtractStateType(out Type? userStateType, this._logger); - KernelProcessStepState stateObject = this._stepInfo.State; stateObject.InitializeUserState(stateType, userStateType); if (stateObject is null) @@ -319,6 +413,8 @@ protected virtual async ValueTask InitializeStepAsync() await this._stepInstance.ActivateAsync(stateObject).ConfigureAwait(false); await activateTask.ConfigureAwait(false); + + await this.SaveStepInfoAsync().ConfigureAwait(false); } /// @@ -330,6 +426,40 @@ public virtual Task DeinitializeStepAsync() return Task.CompletedTask; } + internal (string, string) GetStepStorageKeyValues() + { + return (this._stepInfo.State.StepId, this._stepInfo.State.RunId!); + } + + internal virtual async Task SaveStepStateAsync() + { + if (this.StorageManager != null) + { + await this.StorageManager.SaveStepStateAsync(this.StepInfo).ConfigureAwait(false); + } + } + + internal async Task SaveStepInfoAsync() + { + if (this.StorageManager != null) + { + await this.StorageManager.SaveStepInfoAsync(this.StepInfo).ConfigureAwait(false); + } + } + + /// + /// Helper function that isolate use of Local Runtime specific objects when calling StorageManager + /// + /// + internal async Task SaveStepEventsAsync(ProcessMessage? lastMessageReceived = null) + { + var edgeGroupValues = this._edgeGroupProcessors.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.MessageData); + if (this.StorageManager != null) + { + await this.StorageManager.SaveStepEventsAsync(this.StepInfo, edgeGroupValues).ConfigureAwait(false); + } + } + /// /// Invokes the provides function with the provided kernel and arguments. /// @@ -376,4 +506,24 @@ protected ProcessEvent ScopedEvent(ProcessEvent localEvent) Verify.NotNull(localEvent, nameof(localEvent)); return localEvent with { Namespace = this.Id }; } + + public Task GetUserStateAsync(string key) where T : class + { + if (this._userStateStore is null) + { + throw new NotImplementedException("User state store is not implemented for this step."); + } + + return this._userStateStore.GetUserStateAsync(key); + } + + public Task SetUserStateAsync(string key, T state) where T : class + { + if (this._userStateStore is null) + { + throw new NotImplementedException("User state store is not implemented for this step."); + } + + return this._userStateStore.SetUserStateAsync(key, state); + } } diff --git a/dotnet/src/Experimental/Process.LocalRuntime/LocalUserStateStore.cs b/dotnet/src/Experimental/Process.LocalRuntime/LocalUserStateStore.cs new file mode 100644 index 000000000000..70cc467b7eed --- /dev/null +++ b/dotnet/src/Experimental/Process.LocalRuntime/LocalUserStateStore.cs @@ -0,0 +1,51 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.Threading.Tasks; + +namespace Microsoft.SemanticKernel.Process; + +internal class LocalUserStateStore : IKernelProcessUserStateStore +{ + public Dictionary UserState { get; private set; } = []; + + public void ResetUserState(Dictionary newValues) + { + // Should it reset all dictionary or only update newValues keys? + //this._userState = new Dictionary(newValues, StringComparer.OrdinalIgnoreCase); + foreach (var item in newValues) + { + this.UserState[item.Key] = item.Value; + } + } + + /// + /// Gets the user state of the process. + /// + /// The key to identify the user state. + /// + /// + public Task GetUserStateAsync(string key) where T : class + { + if (this.UserState.TryGetValue(key, out var value) && value is T typedValue) + { + return Task.FromResult(typedValue); + } + + return Task.FromResult(null!); // HACK + } + + /// + /// Sets the user state of the process. + /// + /// + /// + /// + /// + public Task SetUserStateAsync(string key, T state) where T : class + { + this.UserState[key] = state ?? throw new ArgumentNullException(nameof(state), "State cannot be null."); + return Task.CompletedTask; + } +} diff --git a/dotnet/src/Experimental/Process.LocalRuntime/Process.LocalRuntime.csproj b/dotnet/src/Experimental/Process.LocalRuntime/Process.LocalRuntime.csproj index 270e25bf7421..088fc07d5008 100644 --- a/dotnet/src/Experimental/Process.LocalRuntime/Process.LocalRuntime.csproj +++ b/dotnet/src/Experimental/Process.LocalRuntime/Process.LocalRuntime.csproj @@ -17,12 +17,13 @@ Semantic Kernel Process - LocalRuntime - Semantic Kernel Process LocalRuntime. This package is automatically installed by Semantic Kernel Process packages if needed. + Semantic Kernel Process LocalRuntime. This package is automatically installed by + Semantic Kernel Process packages if needed. - + diff --git a/dotnet/src/Experimental/Process.LocalRuntime/README.md b/dotnet/src/Experimental/Process.LocalRuntime/README.md new file mode 100644 index 000000000000..4ba05f9946df --- /dev/null +++ b/dotnet/src/Experimental/Process.LocalRuntime/README.md @@ -0,0 +1,116 @@ +# Local Runtime + +## Pregal Loop + +## Pregal Loop + + +1. **Enqueue external events**: check `_externalMessages` and add them to current execution `messageChannel` queue. +2. **Enqueue Step Messages**: using `step.GetAllEvents()` get all events emitted by all steps in previous iteration and add them to current execution `messageChannel` queue. +3. **Exit check**: + - No more messages in `messageChannel` queue. + - No more external messages getting added to `_externalMessages`. + - `!keepAlive`? + +4. **Process messages**: process messages added to `messageChannel` queue and inject them to matching step event/edges with `step.HandleMessageAsync()`. + +5. **Wait all step with new messages**: wait all steps with new messages to finish processing new messages. `Task.WhenAll(messageTasks)`. + +## Requirements + +- Should only save to storage at the end of pregal superstep iteration. +- Should allow saving intermediate state locally while superstep steps finish running. +- Should allow reading from storage only at process initialization. +- In other instances reading happens from local storage manager. +- For steps: + - save/read step info (name, runningId, parentId, status[does not exist now]) + - save/read step events (edgeGroups messages) + - save/read step state (if any) +- For process: + - save/read process info (name, runningId, children name:running id mapping) + - save/read process events (pending external messages) + - save/read process state (does not exist now) + + +## Checkpointing + +```mermaid +sequenceDiagram + participant External as External System + participant Process as Parent Process + participant Step as Step + participant PSM as ProcessStorageManager + participant IPSC as IProcessStorageConnector + + External->>+Process: Start Process + Process-->>+PSM: Initialize Process Storage Manager + Process-->>PSM: Fetch Process Data From Storage + PSM-->>+IPSC: ReadEntryFromStorage - Process Data + IPSC-->>-PSM: Process Data Retrieved + PSM->>+PSM: Save Process Data locally + + Process-->>+PSM: Get Process Data + PSM-->>-Process: Process Data Retrieved + + loop over Steps + Process->>Process: Create Local Steps with existing runningIds + end + loop over Steps + Process-->>+PSM: Fetch Step Data from Storage + PSM-->>+IPSC: ReadEntryFromStorage - Step Data + activate IPSC + IPSC-->>-PSM: Step Data Retrieved + PSM->>+PSM: Save Step Data locally + end + loop over superSteps + Process->>Process: Enqueue External Messages + Process->>Process: Enqueue Step Messages + + Process->>+Step: Get Step Events + Step-->>-Process: Step Events Retrieved (if any) + + Process->>Process: Exit Check (any messages to be processed) + alt no messages to be processed + Process->>External: Exit Process + end + + + Process->>Process: Process Messages + loop over messages to be distributed + Process->>Process: Find matching Step for message + Process-->>+Step: step.HandleMessageAsync + alt step is not initialized + Step-->>Step: Start Step Initialization + Step-->>+PSM: Get Step State + PSM-->>-Step: Step State Retrieved + Step-->>-Step: Apply saved state to step + Step-->>+PSM: Get Step Events + PSM-->>-Step: Step Events Retrieved + Step-->>Step: Apply pending events if any to edgeGroups + end + + alt edgeGroup has all required messages + Step-->>PSM: Save EdgeGroup Messages + Step-->>+Step: Execute Step + Step-->>PSM: Save Step State + Step-->>PSM: Save Reset EdgeGroup Messages + Step-->>-Process: Step Execution Completed + else + Step-->>PSM: Save EdgeGroup Messages + Step-->>Process: Skipping Step Execution + end + end + + Process-->>Process: Wait for all steps to finish processing messages + + Process-->>+PSM: Save Process Data (State, External Messages) + Process-->>PSM: Save Process Data to Storage + PSM-->>IPSC: WriteEntryToStorage - Process Data + Process-->>PSM: Save children Steps Data to Storage + PSM-->>IPSC: WriteEntryToStorage - Step Data + + end + + + +``` \ No newline at end of file diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ActorStateKeys.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ActorStateKeys.cs index 8aa73d3566ac..78be7c9654aa 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ActorStateKeys.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ActorStateKeys.cs @@ -9,6 +9,7 @@ internal static class ActorStateKeys { // Shared Actor keys public const string StepParentProcessId = "parentProcessId"; + public const string StepId = "stepId"; // StepActor keys public const string StepInfoState = nameof(DaprStepInfo); @@ -21,6 +22,8 @@ internal static class ActorStateKeys // ProcessActor keys public const string ProcessInfoState = nameof(DaprProcessInfo); + public const string ProcessKey = "processKey"; + public const string StepInfoKey = "stepInfoKey"; public const string EventProxyStepId = "processEventProxyId"; public const string StepActivatedState = "kernelStepActivated"; diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/AgentStepActor.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/AgentStepActor.cs new file mode 100644 index 000000000000..794895e59074 --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/AgentStepActor.cs @@ -0,0 +1,55 @@ +// Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; +using System.Threading.Tasks; +using Dapr.Actors.Runtime; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.SemanticKernel.Agents; +using Microsoft.SemanticKernel.Process; +using Microsoft.SemanticKernel.Process.Internal; +using Microsoft.SemanticKernel.Process.Runtime; + +namespace Microsoft.SemanticKernel; + +internal sealed class AgentStepActor : StepActor, IAgentStep +{ + private readonly ILogger? _logger; + + private readonly AgentFactory _agentFactory; + + internal KernelProcessAgentStep? _daprAgentStepInfo; + + /// + /// Initializes a new instance of the class. + /// + /// The Dapr host actor + /// An instance of + /// The registered processes + /// An instance of + public AgentStepActor(ActorHost host, Kernel kernel, IReadOnlyDictionary registeredProcesses, AgentFactory agentFactory) + : base(host, kernel, registeredProcesses) + { + this._agentFactory = agentFactory; + this._logger = this._kernel.LoggerFactory?.CreateLogger(typeof(KernelProxyStep)) ?? new NullLogger(); + } + + internal override KernelProcessStep GetStepInstance() + { + return (KernelProcessAgentExecutor)ActivatorUtilities.CreateInstance(this._kernel.Services, this._innerStepType!, this._agentFactory, this._daprAgentStepInfo!); + } + + internal override Dictionary?> GenerateInitialInputs() + { + return this.FindInputChannels(this._functions, this._logger, agentDefinition: this._daprAgentStepInfo!.AgentDefinition); + } + + public async Task InitializeAgentStepAsync(string processId, string stepId, string? parentProcessId) + { + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + Verify.NotNullOrWhiteSpace(stepId, nameof(stepId)); + + this._daprAgentStepInfo = this._registeredProcesses.GetStepInfo(processId, stepId); + await base.InitializeStepAsync(processId, stepId, parentProcessId).ConfigureAwait(false); + } +} diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/MapActor.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/MapActor.cs index 5892bd0783d9..44f019d824b8 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/MapActor.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/MapActor.cs @@ -20,23 +20,22 @@ internal sealed class MapActor : StepActor, IMap private bool _isInitialized; private HashSet _mapEvents = []; private ILogger? _logger; - private KernelProcessMap? _map; - - internal DaprMapInfo? _mapInfo; + internal KernelProcessMap? _mapInfo; /// /// Initializes a new instance of the class. /// /// The Dapr host actor /// An instance of - public MapActor(ActorHost host, Kernel kernel) - : base(host, kernel) + /// + public MapActor(ActorHost host, Kernel kernel, IReadOnlyDictionary registeredProcesses) + : base(host, kernel, registeredProcesses) { } #region Public Actor Methods - public async Task InitializeMapAsync(DaprMapInfo mapInfo, string? parentProcessId) + public async Task InitializeMapAsync(string processId, string stepId) { // Only initialize once. This check is required as the actor can be re-activated from persisted state and // this should not result in multiple initializations. @@ -45,13 +44,18 @@ public async Task InitializeMapAsync(DaprMapInfo mapInfo, string? parentProcessI return; } - this.InitializeMapActor(mapInfo, parentProcessId); + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + Verify.NotNullOrWhiteSpace(stepId, nameof(stepId)); + + var mapInfo = this._registeredProcesses.GetStepInfo(processId, stepId); + + this.InitializeMapActor(mapInfo, processId); this._isInitialized = true; // Save the state await this.StateManager.AddStateAsync(DaprProcessMapStateName, mapInfo).ConfigureAwait(false); - await this.StateManager.AddStateAsync(ActorStateKeys.StepParentProcessId, parentProcessId).ConfigureAwait(false); + await this.StateManager.AddStateAsync(ActorStateKeys.StepParentProcessId, processId).ConfigureAwait(false); await this.StateManager.SaveStateAsync().ConfigureAwait(false); } @@ -60,22 +64,22 @@ public async Task InitializeMapAsync(DaprMapInfo mapInfo, string? parentProcessI /// rather than ToKernelProcessAsync when extracting the state. /// /// A where T is - public override Task ToDaprStepInfoAsync() => Task.FromResult(this._mapInfo!); + public override Task> GetStepStateAsync() => throw new NotImplementedException(); protected override async Task OnActivateAsync() { - var existingMapInfo = await this.StateManager.TryGetStateAsync(DaprProcessMapStateName).ConfigureAwait(false); - if (existingMapInfo.HasValue) + var existingStepId = await this.StateManager.TryGetStateAsync(ActorStateKeys.StepId).ConfigureAwait(false); + if (existingStepId.HasValue) { this.ParentProcessId = await this.StateManager.GetStateAsync(ActorStateKeys.StepParentProcessId).ConfigureAwait(false); - this.InitializeMapActor(existingMapInfo.Value, this.ParentProcessId); + this.InitializeMapActor(this._registeredProcesses.GetStepInfo(this.ParentProcessId, existingStepId.Value), this.ParentProcessId); } } /// /// The name of the step. /// - protected override string Name => this._mapInfo?.State.Name ?? throw new KernelException("The Map must be initialized before accessing the Name property."); + protected override string Name => this._mapInfo?.State.StepId ?? throw new KernelException("The Map must be initialized before accessing the Name property."); #endregion @@ -86,21 +90,25 @@ protected override async Task OnActivateAsync() internal override async Task HandleMessageAsync(ProcessMessage message) { // Initialize the current operation - (IEnumerable inputValues, KernelProcess mapOperation, string startEventId) = this._map!.Initialize(message, this._logger); + (IEnumerable inputValues, KernelProcess mapOperation, string startEventId) = this._mapInfo!.Initialize(message, this._logger); List mapOperations = []; foreach (var value in inputValues) { - KernelProcess mapProcess = mapOperation with { State = mapOperation.State with { Id = $"{this.Name}-{mapOperations.Count}-{Guid.NewGuid():N}" } }; + KernelProcess mapProcess = mapOperation with { State = mapOperation.State with { RunId = $"{this.Name}-{mapOperations.Count}-{Guid.NewGuid():N}" } }; DaprKernelProcessContext processContext = new(mapProcess); - Task processTask = - processContext.StartWithEventAsync( - new KernelProcessEvent - { - Id = startEventId, - Data = value - }, - eventProxyStepId: this.Id); + + Task processTask = Task.CompletedTask; + + // TODO: This needs to be updated to not dynamically create a process. Map will be broken until then. + //Task processTask = + // processContext.StartWithEventAsync( + // new KernelProcessEvent + // { + // Id = startEventId, + // Data = value + // }, + // eventProxyStepId: this.Id); mapOperations.Add(processTask); } @@ -164,17 +172,16 @@ internal override async Task HandleMessageAsync(ProcessMessage message) } } - private void InitializeMapActor(DaprMapInfo mapInfo, string? parentProcessId) + private void InitializeMapActor(KernelProcessMap mapInfo, string? parentProcessId) { Verify.NotNull(mapInfo); Verify.NotNull(mapInfo.Operation); this._mapInfo = mapInfo; - this._map = mapInfo.ToKernelProcessMap(); this.ParentProcessId = parentProcessId; - this._logger = this._kernel.LoggerFactory?.CreateLogger(this._mapInfo.State.Name) ?? new NullLogger(); + this._logger = this._kernel.LoggerFactory?.CreateLogger(this._mapInfo.State.StepId) ?? new NullLogger(); this._outputEdges = this._mapInfo.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToList()); - this._eventNamespace = $"{this._mapInfo.State.Name}_{this._mapInfo.State.Id}"; + this._eventNamespace = this._mapInfo.State.RunId; // Capture the events that the map is interested in as hashtable for performant lookup this._mapEvents = [.. this._mapInfo.Edges.Keys.Select(key => key.Split(ProcessConstants.EventIdSeparator).Last())]; diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProcessActor.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProcessActor.cs index f28aba6783bc..17dad96e236e 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProcessActor.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProcessActor.cs @@ -25,21 +25,30 @@ internal sealed class ProcessActor : StepActor, IProcess, IDisposable internal readonly List _steps = []; - internal IList? _stepsInfos; - internal DaprProcessInfo? _process; + internal IList? _stepsInfos; + internal KernelProcess? _process; private JoinableTask? _processTask; private CancellationTokenSource? _processCancelSource; private bool _isInitialized; private ILogger? _logger; + private string? _processKey; /// /// Initializes a new instance of the class. /// /// The Dapr host actor /// An instance of - public ProcessActor(ActorHost host, Kernel kernel) - : base(host, kernel) + /// The registered processes + public ProcessActor(ActorHost host, Kernel kernel, IReadOnlyDictionary registeredProcesses) + : base(host, kernel, registeredProcesses) { + Verify.NotNull(registeredProcesses, nameof(registeredProcesses)); + + if (registeredProcesses.Count == 0) + { + throw new ArgumentException("The registered processes cannot be empty.", nameof(registeredProcesses)); + } + this._externalEventChannel = Channel.CreateUnbounded(); this._joinableTaskContext = new JoinableTaskContext(); this._joinableTaskFactory = new JoinableTaskFactory(this._joinableTaskContext); @@ -47,10 +56,14 @@ public ProcessActor(ActorHost host, Kernel kernel) #region Public Actor Methods - public async Task InitializeProcessAsync(DaprProcessInfo processInfo, string? parentProcessId, string? eventProxyStepId = null) + public async Task InitializeProcessAsync(string processKey, string? parentProcessId, string? eventProxyStepId = null) { - Verify.NotNull(processInfo); - Verify.NotNull(processInfo.Steps); + Verify.NotNullOrWhiteSpace(processKey); + + if (!this._registeredProcesses.TryGetValue(processKey, out KernelProcess? process) || process is null) + { + throw new KernelException("The specified process key could not be found"); + } // Only initialize once. This check is required as the actor can be re-activated from persisted state and // this should not result in multiple initializations. @@ -60,10 +73,10 @@ public async Task InitializeProcessAsync(DaprProcessInfo processInfo, string? pa } // Initialize the process - await this.InitializeProcessActorAsync(processInfo, parentProcessId, eventProxyStepId).ConfigureAwait(false); + await this.InitializeProcessActorAsync(process, parentProcessId, eventProxyStepId).ConfigureAwait(false); // Save the state - await this.StateManager.AddStateAsync(ActorStateKeys.ProcessInfoState, processInfo).ConfigureAwait(false); + await this.StateManager.AddStateAsync(ActorStateKeys.ProcessKey, processKey).ConfigureAwait(false); await this.StateManager.AddStateAsync(ActorStateKeys.StepParentProcessId, parentProcessId).ConfigureAwait(false); await this.StateManager.AddStateAsync(ActorStateKeys.StepActivatedState, true).ConfigureAwait(false); if (!string.IsNullOrWhiteSpace(eventProxyStepId)) @@ -92,6 +105,29 @@ public Task StartAsync(bool keepAlive) return Task.CompletedTask; } + /// + /// Starts the process with an initial event and an optional kernel. + /// + /// The registration key of the process. + /// The unique Id of the process. + /// The unique Id of the parent process. + /// The unique Id of the associated step proxy. + /// The process event. + /// + public async Task KeyedRunOnceAsync(string processKey, string processId, string parentProcessId, string? eventProxyStepId, string processEvent) + { + //if (!this._registeredProcesses.TryGetValue(processKey, out KernelProcess? process) || process is null) + //{ + // throw new ArgumentException($"The process with key '{processKey}' is not registered.", nameof(processKey)); + //} + + this._processKey = processKey; // TODO: save state + //var processWithId = process with { State = process.State with { RunId = processId } }; + //var daprProcess = DaprProcessInfo.FromKernelProcess(processWithId); + await this.InitializeProcessAsync(processKey, null, eventProxyStepId).ConfigureAwait(false); + await this.RunOnceAsync(processEvent).ConfigureAwait(false); + } + /// /// Starts the process with an initial event and then waits for the process to finish. In this case the process will not /// keep alive waiting for external events after the internal messages have stopped. @@ -151,7 +187,7 @@ public async Task SendMessageAsync(string processEvent) /// Gets the process information. /// /// An instance of - public async Task GetProcessInfoAsync() + public async Task> GetProcessInfoAsync() { return await this.ToDaprProcessInfoAsync().ConfigureAwait(false); } @@ -161,30 +197,37 @@ public async Task GetProcessInfoAsync() /// rather than ToKernelProcessAsync when extracting the state. /// /// A - public override async Task ToDaprStepInfoAsync() + public override Task> GetStepStateAsync() { - return await this.ToDaprProcessInfoAsync().ConfigureAwait(false); + var processStepState = new Dictionary() { { this._process!.State.StepId, this._process.State } }; + return Task.FromResult((IDictionary)processStepState); } protected override async Task OnActivateAsync() { - var existingProcessInfo = await this.StateManager.TryGetStateAsync(ActorStateKeys.ProcessInfoState).ConfigureAwait(false); - if (existingProcessInfo.HasValue) + var existingProcessKey = await this.StateManager.TryGetStateAsync(ActorStateKeys.ProcessKey).ConfigureAwait(false); + if (existingProcessKey.HasValue) { + string processKey = existingProcessKey.Value; this.ParentProcessId = await this.StateManager.GetStateAsync(ActorStateKeys.StepParentProcessId).ConfigureAwait(false); string? eventProxyStepId = null; if (await this.StateManager.ContainsStateAsync(ActorStateKeys.EventProxyStepId).ConfigureAwait(false)) { eventProxyStepId = await this.StateManager.GetStateAsync(ActorStateKeys.EventProxyStepId).ConfigureAwait(false); } - await this.InitializeProcessActorAsync(existingProcessInfo.Value, this.ParentProcessId, eventProxyStepId).ConfigureAwait(false); + + if (!this._registeredProcesses.TryGetValue(processKey, out KernelProcess? process) || process is null) + { + throw new ArgumentException($"The process with key '{processKey}' is not registered.", nameof(processKey)); + } + await this.InitializeProcessActorAsync(process, this.ParentProcessId, eventProxyStepId).ConfigureAwait(false); } } /// /// The name of the step. /// - protected override string Name => this._process?.State.Name ?? throw new KernelException("The Process must be initialized before accessing the Name property.").Log(this._logger); + protected override string Name => this._process?.State.StepId ?? throw new KernelException("The Process must be initialized before accessing the Name property.").Log(this._logger); #endregion @@ -230,15 +273,15 @@ protected override ValueTask ActivateStepAsync() return default; } - private async Task InitializeProcessActorAsync(DaprProcessInfo processInfo, string? parentProcessId, string? eventProxyStepId) + private async Task InitializeProcessActorAsync(KernelProcess process, string? parentProcessId, string? eventProxyStepId) { - Verify.NotNull(processInfo, nameof(processInfo)); - Verify.NotNull(processInfo.Steps); + Verify.NotNull(process, nameof(process)); + Verify.NotNull(process.Steps); this.ParentProcessId = parentProcessId; - this._process = processInfo; + this._process = process; this._stepsInfos = [.. this._process.Steps]; - this._logger = this._kernel.LoggerFactory?.CreateLogger(this._process.State.Name) ?? new NullLogger(); + this._logger = this._kernel.LoggerFactory?.CreateLogger(this._process.State.StepId) ?? new NullLogger(); if (!string.IsNullOrWhiteSpace(eventProxyStepId)) { this.EventProxyStepId = new ActorId(eventProxyStepId); @@ -253,46 +296,54 @@ private async Task InitializeProcessActorAsync(DaprProcessInfo processInfo, stri IStep? stepActor = null; // The current step should already have a name. - Verify.NotNull(step.State?.Name); + Verify.NotNull(step.State?.StepId); - if (step is DaprProcessInfo processStep) + if (string.IsNullOrWhiteSpace(step.State.RunId)) { - // The process will only have an Id if its already been executed. - if (string.IsNullOrWhiteSpace(processStep.State.Id)) - { - processStep = processStep with { State = processStep.State with { Id = Guid.NewGuid().ToString() } }; - } + // assigning running id to step if it does not have one, if it has one the step ran before + step.State.RunId = Guid.NewGuid().ToString(); + } + if (step is KernelProcess processStep) + { // Initialize the step as a process. - var scopedProcessId = this.ScopedActorId(new ActorId(processStep.State.Id!)); + var scopedProcessId = this.ScopedActorId(new ActorId(processStep.State.RunId!)); var processActor = this.ProxyFactory.CreateActorProxy(scopedProcessId, nameof(ProcessActor)); - await processActor.InitializeProcessAsync(processStep, this.Id.GetId(), eventProxyStepId).ConfigureAwait(false); + await processActor.InitializeProcessAsync(processStep.State.StepId, this.Id.GetId(), eventProxyStepId).ConfigureAwait(false); // TODO: specifying the process key as processStep.State.StepId is not correct. Can we make the key and the process Id the same? stepActor = this.ProxyFactory.CreateActorProxy(scopedProcessId, nameof(ProcessActor)); } - else if (step is DaprMapInfo mapStep) + else if (step is KernelProcessMap mapStep) { // Initialize the step as a map. - ActorId scopedMapId = this.ScopedActorId(new ActorId(mapStep.State.Id!)); + ActorId scopedMapId = this.ScopedActorId(new ActorId(mapStep.State.RunId!)); IMap mapActor = this.ProxyFactory.CreateActorProxy(scopedMapId, nameof(MapActor)); - await mapActor.InitializeMapAsync(mapStep, this.Id.GetId()).ConfigureAwait(false); + await mapActor.InitializeMapAsync(process.State.StepId, mapStep.State.StepId).ConfigureAwait(false); stepActor = this.ProxyFactory.CreateActorProxy(scopedMapId, nameof(MapActor)); } - else if (step is DaprProxyInfo proxyStep) + else if (step is KernelProcessProxy proxyStep) { // Initialize the step as a proxy - ActorId scopedProxyId = this.ScopedActorId(new ActorId(proxyStep.State.Id!)); + ActorId scopedProxyId = this.ScopedActorId(new ActorId(proxyStep.State.RunId!)); IProxy proxyActor = this.ProxyFactory.CreateActorProxy(scopedProxyId, nameof(ProxyActor)); - await proxyActor.InitializeProxyAsync(proxyStep, this.Id.GetId()).ConfigureAwait(false); + await proxyActor.InitializeProxyAsync(process.State.StepId, proxyStep.State.StepId, this.Id.GetId()).ConfigureAwait(false); stepActor = this.ProxyFactory.CreateActorProxy(scopedProxyId, nameof(ProxyActor)); } + else if (step is KernelProcessAgentStep agentStepInfo) + { + // Initialize the step as a proxy + ActorId scopedAgentStepId = this.ScopedActorId(new ActorId(agentStepInfo.State.RunId!)); + IAgentStep agentActor = this.ProxyFactory.CreateActorProxy(scopedAgentStepId, nameof(AgentStepActor)); + await agentActor.InitializeAgentStepAsync(process.State.StepId, agentStepInfo.State.StepId, this.Id.GetId()).ConfigureAwait(false); + stepActor = this.ProxyFactory.CreateActorProxy(scopedAgentStepId, nameof(AgentStepActor)); + } else { // The current step should already have an Id. - Verify.NotNull(step.State?.Id); + Verify.NotNull(step.State?.RunId); - var scopedStepId = this.ScopedActorId(new ActorId(step.State.Id!)); + var scopedStepId = this.ScopedActorId(new ActorId(step.State.RunId!)); stepActor = this.ProxyFactory.CreateActorProxy(scopedStepId, nameof(StepActor)); - await stepActor.InitializeStepAsync(step, this.Id.GetId(), eventProxyStepId).ConfigureAwait(false); + await stepActor.InitializeStepAsync(process.State.StepId, step.State.StepId, this.Id.GetId(), eventProxyStepId).ConfigureAwait(false); } this._steps.Add(stepActor); @@ -416,12 +467,13 @@ private async Task HandleGlobalErrorMessageAsync() IList processErrorEvents = errorEvents.ToProcessEvents(); foreach (var errorEdge in errorEdges) { + if (errorEdge.OutputTarget is not KernelProcessFunctionTarget functionTarget) + { + throw new KernelException("Only KernelProcessFunctionTarget can be used as input events."); + } + foreach (ProcessEvent errorEvent in processErrorEvents) { - if (errorEdge.OutputTarget is not KernelProcessFunctionTarget functionTarget) - { - throw new KernelException("The target for the edge is not a function target.").Log(this._logger); - } var errorMessage = ProcessMessageFactory.CreateFromEdge(errorEdge, errorEvent.SourceId, errorEvent.Data); var scopedErrorMessageBufferId = this.ScopedActorId(new ActorId(functionTarget.StepId)); var errorStepQueue = this.ProxyFactory.CreateActorProxy(scopedErrorMessageBufferId, nameof(MessageBufferActor)); @@ -483,12 +535,22 @@ private async Task IsEndMessageSentAsync() /// /// An instance of /// - private async Task ToDaprProcessInfoAsync() + private async Task> ToDaprProcessInfoAsync() { - var processState = new KernelProcessState(this.Name, this._process!.State.Version, this.Id.GetId()); - var stepTasks = this._steps.Select(step => step.ToDaprStepInfoAsync()).ToList(); + var stepStates = new Dictionary(); + + var stepTasks = this._steps.Select(step => step.GetStepStateAsync()).ToList(); var steps = await Task.WhenAll(stepTasks).ConfigureAwait(false); - return new DaprProcessInfo { InnerStepDotnetType = this._process!.InnerStepDotnetType, Edges = this._process!.Edges, State = processState, Steps = [.. steps] }; + + foreach (var step in steps) + { + foreach (var kvp in step) + { + stepStates.Add(kvp.Key, kvp.Value); + } + } + + return stepStates; } /// @@ -516,7 +578,7 @@ private ActorId ScopedActorId(ActorId actorId, bool scopeToParent = false) private ProcessEvent ScopedEvent(ProcessEvent daprEvent) { Verify.NotNull(daprEvent); - return daprEvent with { Namespace = $"{this.Name}_{this._process!.State.Id}" }; + return daprEvent with { Namespace = this._process!.State.RunId ?? throw new KernelException("Id not set in process state.") }; } #endregion diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProxyActor.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProxyActor.cs index 5d64b0fbdd6f..6644cd30b43d 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProxyActor.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/ProxyActor.cs @@ -1,4 +1,5 @@ // Copyright (c) Microsoft. All rights reserved. + using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; @@ -16,15 +17,16 @@ internal sealed class ProxyActor : StepActor, IProxy { private readonly ILogger? _logger; - internal DaprProxyInfo? _daprProxyInfo; + internal KernelProcessProxy? _proxyInfo; /// /// Initializes a new instance of the class. /// /// The Dapr host actor /// An instance of - public ProxyActor(ActorHost host, Kernel kernel) - : base(host, kernel) + /// The registered processes + public ProxyActor(ActorHost host, Kernel kernel, IReadOnlyDictionary registeredProcesses) + : base(host, kernel, registeredProcesses) { this._logger = this._kernel.LoggerFactory?.CreateLogger(typeof(KernelProxyStep)) ?? new NullLogger(); } @@ -54,7 +56,7 @@ internal override void AssignStepFunctionParameterValues(ProcessMessage message) functionParameters = this._inputs[message.FunctionName]; } - if (this._daprProxyInfo?.ProxyMetadata != null && message.SourceEventId != null && this._daprProxyInfo.ProxyMetadata.EventMetadata.TryGetValue(message.SourceEventId, out var metadata) && metadata != null) + if (this._proxyInfo?.ProxyMetadata != null && message.SourceEventId != null && this._proxyInfo.ProxyMetadata.EventMetadata.TryGetValue(message.SourceEventId, out var metadata) && metadata != null) { functionParameters![kvp.Key] = KernelProcessProxyMessageFactory.CreateProxyMessage(this.ParentProcessId!, message.SourceEventId, metadata.TopicName, kvp.Value); } @@ -71,10 +73,12 @@ internal override void AssignStepFunctionParameterValues(ProcessMessage message) return this.FindInputChannels(this._functions, this._logger, externalMessageChannelActor); } - public async Task InitializeProxyAsync(DaprProxyInfo proxyInfo, string? parentProcessId) + public async Task InitializeProxyAsync(string processId, string stepId, string? parentProcessId) { - this._daprProxyInfo = proxyInfo; + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + Verify.NotNullOrWhiteSpace(stepId, nameof(stepId)); - await base.InitializeStepAsync(proxyInfo, parentProcessId).ConfigureAwait(false); + this._proxyInfo = this._registeredProcesses.GetStepInfo(processId, stepId); + await base.InitializeStepAsync(processId, stepId, parentProcessId).ConfigureAwait(false); } } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/StepActor.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/StepActor.cs index 27bda37176fb..87e0c4ff4c11 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/StepActor.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Actors/StepActor.cs @@ -19,17 +19,19 @@ namespace Microsoft.SemanticKernel; internal class StepActor : Actor, IStep, IKernelProcessMessageChannel { - private readonly Lazy _activateTask; + protected readonly Lazy _activateTask; + protected readonly IReadOnlyDictionary _registeredProcesses; + protected Dictionary _edgeGroupProcessors = []; - private DaprStepInfo? _stepInfo; + private KernelProcessStepInfo? _stepInfo; private ILogger? _logger; - private Type? _innerStepType; private bool _isInitialized; protected readonly Kernel _kernel; protected string? _eventNamespace; + internal Type? _innerStepType; internal Queue _incomingMessages = new(); internal KernelProcessStepState? _stepState; internal Type? _stepStateType; @@ -46,11 +48,15 @@ internal class StepActor : Actor, IStep, IKernelProcessMessageChannel /// /// The host. /// Required. An instance of . - public StepActor(ActorHost host, Kernel kernel) + /// + public StepActor(ActorHost host, Kernel kernel, IReadOnlyDictionary registeredProcesses) : base(host) { + Verify.NotNull(kernel, nameof(kernel)); + this._kernel = kernel; this._activateTask = new Lazy(this.ActivateStepAsync); + this._registeredProcesses = registeredProcesses; } #region Public Actor Methods @@ -58,13 +64,24 @@ public StepActor(ActorHost host, Kernel kernel) /// /// Initializes the step with the provided step information. /// - /// The instance describing the step. + /// + /// /// The Id of the parent process if one exists. /// An optional identifier of an actor requesting to proxy events. /// A - public async Task InitializeStepAsync(DaprStepInfo stepInfo, string? parentProcessId, string? eventProxyStepId = null) + public async Task InitializeStepAsync(string processId, string stepId, string? parentProcessId, string? eventProxyStepId = null) { - Verify.NotNull(stepInfo, nameof(stepInfo)); + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + Verify.NotNullOrWhiteSpace(stepId, nameof(stepId)); + + if (!this._registeredProcesses.TryGetValue(processId, out var registeredProcess) || registeredProcess is null) + { + throw new InvalidOperationException("No process registered with the specified key"); + } + + var currentStep = this._registeredProcesses.GetStepInfo(processId, stepId); + + this._edgeGroupProcessors = currentStep.IncomingEdgeGroups?.ToDictionary(kvp => kvp.Key, kvp => new DaprEdgeGroupProcessor(kvp.Value)) ?? []; // Only initialize once. This check is required as the actor can be re-activated from persisted state and // this should not result in multiple initializations. @@ -73,10 +90,10 @@ public async Task InitializeStepAsync(DaprStepInfo stepInfo, string? parentProce return; } - this.InitializeStep(stepInfo, parentProcessId, eventProxyStepId); + this.InitializeStep(currentStep, parentProcessId, eventProxyStepId); // Save initial state - await this.StateManager.AddStateAsync(ActorStateKeys.StepInfoState, stepInfo).ConfigureAwait(false); + await this.StateManager.AddStateAsync(ActorStateKeys.StepInfoKey, stepId).ConfigureAwait(false); await this.StateManager.AddStateAsync(ActorStateKeys.StepParentProcessId, parentProcessId).ConfigureAwait(false); if (!string.IsNullOrWhiteSpace(eventProxyStepId)) { @@ -91,15 +108,15 @@ public async Task InitializeStepAsync(DaprStepInfo stepInfo, string? parentProce /// The instance describing the step. /// The Id of the parent process if one exists. /// An optional identifier of an actor requesting to proxy events. - private void InitializeStep(DaprStepInfo stepInfo, string? parentProcessId, string? eventProxyStepId = null) + protected virtual void InitializeStep(KernelProcessStepInfo stepInfo, string? parentProcessId, string? eventProxyStepId = null) { Verify.NotNull(stepInfo, nameof(stepInfo)); // Attempt to load the inner step type - this._innerStepType = Type.GetType(stepInfo.InnerStepDotnetType); + this._innerStepType = stepInfo.InnerStepType; if (this._innerStepType is null) { - throw new KernelException($"Could not load the inner step type '{stepInfo.InnerStepDotnetType}'.").Log(this._logger); + throw new KernelException($"Could not load the inner step type '{stepInfo.InnerStepType}'.").Log(this._logger); } this.ParentProcessId = parentProcessId; @@ -107,7 +124,7 @@ private void InitializeStep(DaprStepInfo stepInfo, string? parentProcessId, stri this._stepState = this._stepInfo.State; this._logger = this._kernel.LoggerFactory?.CreateLogger(this._innerStepType) ?? new NullLogger(); this._outputEdges = this._stepInfo.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToList()); - this._eventNamespace = $"{this._stepInfo.State.Name}_{this._stepInfo.State.Id}"; + this._eventNamespace = this._stepInfo.State.RunId; if (!string.IsNullOrWhiteSpace(eventProxyStepId)) { @@ -161,14 +178,13 @@ public async Task ProcessIncomingMessagesAsync() /// Extracts the current state of the step and returns it as a . /// /// An instance of - public virtual async Task ToDaprStepInfoAsync() + public virtual async Task> GetStepStateAsync() { // Lazy one-time initialization of the step before extracting state information. // This allows state information to be extracted even if the step has not been activated. await this._activateTask.Value.ConfigureAwait(false); - var stepInfo = new DaprStepInfo { InnerStepDotnetType = this._stepInfo!.InnerStepDotnetType!, State = this._stepInfo.State, Edges = this._stepInfo.Edges! }; - return stepInfo; + return new Dictionary() { { this._stepInfo!.State.StepId, this._stepState } }; } /// @@ -177,8 +193,8 @@ public virtual async Task ToDaprStepInfoAsync() /// A protected override async Task OnActivateAsync() { - var existingStepInfo = await this.StateManager.TryGetStateAsync(ActorStateKeys.StepInfoState).ConfigureAwait(false); - if (existingStepInfo.HasValue) + var existingStepId = await this.StateManager.TryGetStateAsync(ActorStateKeys.StepInfoKey).ConfigureAwait(false); + if (existingStepId.HasValue) { // Initialize the step from persisted state string? parentProcessId = await this.StateManager.GetStateAsync(ActorStateKeys.StepParentProcessId).ConfigureAwait(false); @@ -187,7 +203,9 @@ protected override async Task OnActivateAsync() { eventProxyStepId = await this.StateManager.GetStateAsync(ActorStateKeys.EventProxyStepId).ConfigureAwait(false); } - this.InitializeStep(existingStepInfo.Value, parentProcessId, eventProxyStepId); + + var step = this._registeredProcesses.GetStepInfo(parentProcessId, existingStepId.Value); + this.InitializeStep(step, parentProcessId, eventProxyStepId); // Load the persisted incoming messages var incomingMessages = await this.StateManager.TryGetStateAsync>(ActorStateKeys.StepIncomingMessagesState).ConfigureAwait(false); @@ -203,7 +221,7 @@ protected override async Task OnActivateAsync() /// /// The name of the step. /// - protected virtual string Name => this._stepInfo?.State.Name ?? throw new KernelException("The Step must be initialized before accessing the Name property.").Log(this._logger); + protected virtual string Name => this._stepInfo?.State.StepId ?? throw new KernelException("The Step must be initialized before accessing the Name property.").Log(this._logger); /// /// Emits an event from the step. @@ -266,6 +284,24 @@ internal virtual async Task HandleMessageAsync(ProcessMessage message) string messageLogParameters = string.Join(", ", message.Values.Select(kvp => $"{kvp.Key}: {kvp.Value}")); this._logger?.LogDebug("Received message from '{SourceId}' targeting function '{FunctionName}' and parameters '{Parameters}'.", message.SourceId, message.FunctionName, messageLogParameters); + if (!string.IsNullOrEmpty(message.GroupId)) + { + this._logger?.LogDebug("Step {StepName} received message from Step named '{SourceId}' with group Id '{GroupId}'.", this.Name, message.SourceId, message.GroupId); + if (!this._edgeGroupProcessors.TryGetValue(message.GroupId, out DaprEdgeGroupProcessor? edgeGroupProcessor) || edgeGroupProcessor is null) + { + throw new KernelException($"Step {this.Name} received message from Step named '{message.SourceId}' with group Id '{message.GroupId}' that is not registered.").Log(this._logger); + } + + if (!edgeGroupProcessor.TryGetResult(message, out Dictionary? result)) + { + // The edge group processor has not received all required messages yet. + return; + } + + // The edge group processor has received all required messages and has produced a result. + message = message with { Values = result ?? [] }; + } + // Add the message values to the inputs for the function this.AssignStepFunctionParameterValues(message); @@ -338,6 +374,11 @@ await this.EmitEventAsync( return this.FindInputChannels(this._functions, this._logger); } + internal virtual KernelProcessStep GetStepInstance() + { + return (KernelProcessStep)ActivatorUtilities.CreateInstance(this._kernel.Services, this._innerStepType!); + } + /// /// Initializes the step with the provided step information. /// @@ -351,8 +392,9 @@ protected virtual async ValueTask ActivateStepAsync() } // Instantiate an instance of the inner step object - KernelProcessStep stepInstance = (KernelProcessStep)ActivatorUtilities.CreateInstance(this._kernel.Services, this._innerStepType!); - var kernelPlugin = KernelPluginFactory.CreateFromObject(stepInstance, pluginName: this._stepInfo.State.Name); + KernelProcessStep stepInstance = this.GetStepInstance(); + + var kernelPlugin = KernelPluginFactory.CreateFromObject(stepInstance!, pluginName: this._stepInfo.State.StepId); // Load the kernel functions foreach (KernelFunction f in kernelPlugin) diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprAgentStepInfo.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprAgentStepInfo.cs new file mode 100644 index 000000000000..d31eb115efd5 --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprAgentStepInfo.cs @@ -0,0 +1,69 @@ +// Copyright (c) Microsoft. All rights reserved. +using System.Runtime.Serialization; +using Microsoft.SemanticKernel.Agents; + +namespace Microsoft.SemanticKernel; + +/// +/// A serializable representation of a Dapr Proxy. +/// +[KnownType(typeof(KernelProcessEdge))] +[KnownType(typeof(KernelProcessStepState))] +[KnownType(typeof(KernelProcessStepState))] +[KnownType(typeof(KernelProcessAgentExecutorState))] +[KnownType(typeof(ProcessAgentActions))] +public sealed record DaprAgentStepInfo : DaprStepInfo +{ + /// + /// The agent definition associated with this step. + /// + public required AgentDefinition AgentDefinition { get; init; } + + /// + /// The handler group for code-based actions. + /// + public required ProcessAgentActions Actions { get; init; } + + /// + /// The inputs for this agent. + /// + public required NodeInputs Inputs { get; init; } + + /// + /// Initializes a new instance of the class from this instance of . + /// + /// An instance of + /// + public KernelProcessAgentStep ToKernelProcessAgentStep() + { + KernelProcessStepInfo processStepInfo = this.ToKernelProcessStepInfo(); + if (this.State is not KernelProcessStepState state) + { + throw new KernelException($"Unable to read state from agent step with name '{this.State.StepId}', Id '{this.State.RunId}' and type {this.State.GetType()}."); + } + + return new KernelProcessAgentStep(this.AgentDefinition, this.Actions, this.State, this.Edges, threadName: "", inputs: []); // TODO: Set threadName + } + + /// + /// Initializes a new instance of the class from an instance of . + /// + /// The used to build the + /// + public static DaprAgentStepInfo FromKernelProcessAgentStep(KernelProcessAgentStep kernelAgentStepInfo) + { + Verify.NotNull(kernelAgentStepInfo, nameof(kernelAgentStepInfo)); + + DaprStepInfo agentStepInfo = DaprStepInfo.FromKernelStepInfo(kernelAgentStepInfo); + + return new DaprAgentStepInfo + { + InnerStepDotnetType = agentStepInfo.InnerStepDotnetType, + State = agentStepInfo.State, + Edges = agentStepInfo.Edges, + AgentDefinition = kernelAgentStepInfo.AgentDefinition, + Inputs = new(), + Actions = kernelAgentStepInfo.Actions, + }; + } +} diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprEdgeGroupProcessor.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprEdgeGroupProcessor.cs new file mode 100644 index 000000000000..cd8f8c105b1a --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprEdgeGroupProcessor.cs @@ -0,0 +1,90 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Text.Json; +using Microsoft.SemanticKernel.Process.Runtime; + +namespace Microsoft.SemanticKernel; +internal class DaprEdgeGroupProcessor +{ + private readonly KernelProcessEdgeGroup _edgeGroup; + private readonly Dictionary _messageData = []; + private HashSet _requiredMessages = new(); + private HashSet _absentMessages = new(); + + public DaprEdgeGroupProcessor(KernelProcessEdgeGroup edgeGroup) + { + Verify.NotNull(edgeGroup, nameof(edgeGroup)); + this._edgeGroup = edgeGroup; + + this.InitializeEventTracking(); + } + + public bool TryGetResult(ProcessMessage message, out Dictionary? result) + { + string messageKey = this.GetKeyForMessageSource(message); + if (!this._requiredMessages.Contains(messageKey)) + { + throw new KernelException($"Message {messageKey} is not expected for edge group {this._edgeGroup.GroupId}."); + } + + if (message.TargetEventData is KernelProcessEventData eventData) + { + this._messageData[messageKey] = (message.TargetEventData as KernelProcessEventData)!.ToObject(); + } + else if (message.TargetEventData is JsonElement jsonElement) + { + var deserialized = jsonElement.Deserialize(); + if (deserialized != null) + { + this._messageData[messageKey] = deserialized.Content; + } + } + else + { + this._messageData[messageKey] = message.TargetEventData; + } + + this._absentMessages.Remove(messageKey); + if (this._absentMessages.Count == 0) + { + // We have received all required events so forward them to the target + result = (Dictionary?)this._edgeGroup.InputMapping(this._messageData); + + // TODO: Reset state according to configured logic i.e. reset after first message or after all messages are received. + this.InitializeEventTracking(); + + return true; + } + + result = null; + return false; + } + + private void InitializeEventTracking() + { + this._requiredMessages = this.BuildRequiredEvents(this._edgeGroup.MessageSources); + this._absentMessages = [.. this._requiredMessages]; + } + + private HashSet BuildRequiredEvents(List messageSources) + { + var requiredEvents = new HashSet(); + foreach (var source in messageSources) + { + requiredEvents.Add(this.GetKeyForMessageSource(source)); + } + + return requiredEvents; + } + + private string GetKeyForMessageSource(KernelProcessMessageSource messageSource) + { + return $"{messageSource.SourceStepId}.{messageSource.MessageType}"; + } + + private string GetKeyForMessageSource(ProcessMessage message) + { + return $"{message.SourceId}.{message.SourceEventId}"; + } +} diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessContext.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessContext.cs index 64ed08b63820..42ab10559691 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessContext.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessContext.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Collections.Generic; using System.Threading.Tasks; using Dapr.Actors; using Dapr.Actors.Client; @@ -20,15 +21,15 @@ public class DaprKernelProcessContext : KernelProcessContext internal DaprKernelProcessContext(KernelProcess process, IActorProxyFactory? actorProxyFactory = null) { Verify.NotNull(process); - Verify.NotNullOrWhiteSpace(process.State?.Name); + Verify.NotNullOrWhiteSpace(process.State?.StepId); - if (string.IsNullOrWhiteSpace(process.State.Id)) + if (string.IsNullOrWhiteSpace(process.State.RunId)) { - process = process with { State = process.State with { Id = Guid.NewGuid().ToString() } }; + process = process with { State = process.State with { RunId = Guid.NewGuid().ToString() } }; } this._process = process; - var processId = new ActorId(process.State.Id); + var processId = new ActorId(process.State.RunId); // For a non-dependency-injected application, the static methods on ActorProxy are used. // Since the ActorProxy methods are error prone, try to avoid using them when using @@ -46,13 +47,14 @@ internal DaprKernelProcessContext(KernelProcess process, IActorProxyFactory? act /// /// Starts the process with an initial event. /// + /// The registration key of the Process to be run. + /// The unique Id of the process to be run. /// The initial event. - /// An optional identifier of an actor requesting to proxy events. - internal async Task StartWithEventAsync(KernelProcessEvent initialEvent, ActorId? eventProxyStepId = null) + /// The id of the event proxy. + /// + internal async Task KeyedStartWithEventAsync(string key, string processId, KernelProcessEvent initialEvent, ActorId? eventProxyStepId = null) { - var daprProcess = DaprProcessInfo.FromKernelProcess(this._process); - await this._daprProcess.InitializeProcessAsync(daprProcess, null, eventProxyStepId?.GetId()).ConfigureAwait(false); - await this._daprProcess.RunOnceAsync(initialEvent.ToJson()).ConfigureAwait(false); + await this._daprProcess.KeyedRunOnceAsync(key, processId, "", eventProxyStepId?.GetId(), initialEvent.ToJson()).ConfigureAwait(false); } /// @@ -69,14 +71,32 @@ public override async Task SendEventAsync(KernelProcessEvent processEvent) => /// A public override async Task StopAsync() => await this._daprProcess.StopAsync().ConfigureAwait(false); + /// + /// Gets a snapshot of the step states. + /// + public override async Task> GetStepStatesAsync() + { + IDictionary stepStates = await this._daprProcess.GetProcessInfoAsync().ConfigureAwait(false); + return stepStates; + } + /// /// Gets a snapshot of the current state of the process. /// /// A where T is public override async Task GetStateAsync() { - var daprProcessInfo = await this._daprProcess.GetProcessInfoAsync().ConfigureAwait(false); - return daprProcessInfo.ToKernelProcess(); + IDictionary stepStates = await this._daprProcess.GetProcessInfoAsync().ConfigureAwait(false); + + // Build the process with the new state + List kernelProcessSteps = []; + + foreach (var step in this._process.Steps) + { + kernelProcessSteps.Add(step with { State = stepStates[step.State.StepId] }); + } + + return this._process with { Steps = kernelProcessSteps }; } /// @@ -88,7 +108,7 @@ public override async Task GetStateAsync() /// public override async Task GetProcessIdAsync() { - var processInfo = await this._daprProcess.GetProcessInfoAsync().ConfigureAwait(false); - return processInfo.State.Id!; + var processInfo = await this.GetStateAsync().ConfigureAwait(false); + return processInfo.State.RunId!; } } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessFactory.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessFactory.cs index 9d2155ae8955..4d450c06366f 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessFactory.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprKernelProcessFactory.cs @@ -1,36 +1,56 @@ // Copyright (c) Microsoft. All rights reserved. +using System; +using System.Collections.Generic; using System.Threading.Tasks; using Dapr.Actors.Client; namespace Microsoft.SemanticKernel; + /// -/// A class that can run a process locally or in-process. +/// A factory for creating and starting Dapr kernel processes. /// -public static class DaprKernelProcessFactory +public class DaprKernelProcessFactory { + private readonly IReadOnlyDictionary _registeredProcesses; + + /// + /// Creates a new instance of the class. + /// + /// + public DaprKernelProcessFactory(IReadOnlyDictionary registeredProcesses) + { + Verify.NotNull(registeredProcesses, nameof(registeredProcesses)); + + this._registeredProcesses = registeredProcesses; + } + /// /// Starts the specified process. /// - /// Required: The to start running. - /// Required: The initial event to start the process. - /// Optional: Used to specify the unique Id of the process. If the process already has an Id, it will not be overwritten and this parameter has no effect. - /// Optional: when using in application with dependency injection it is recommended to pass the - /// An instance of that can be used to interrogate or stop the running process. - public static async Task StartAsync(this KernelProcess process, KernelProcessEvent initialEvent, string? processId = null, IActorProxyFactory? actorProxyFactory = null) + /// The registration key for the process to be run. + /// The Id of the process run. + /// The initial event. + /// An instance of + /// + public async Task StartAsync(string key, string processId, KernelProcessEvent initialEvent, IActorProxyFactory? actorProxyFactory = null) { - Verify.NotNull(process); - Verify.NotNullOrWhiteSpace(process.State?.Name); - Verify.NotNull(initialEvent); + Verify.NotNullOrWhiteSpace(key, nameof(key)); + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + + if (!this._registeredProcesses.TryGetValue(key, out KernelProcess? process) || process is null) + { + throw new ArgumentException($"The process with key '{key}' is not registered.", nameof(key)); + } // Assign the process Id if one is provided and the processes does not already have an Id. - if (!string.IsNullOrWhiteSpace(processId) && string.IsNullOrWhiteSpace(process.State.Id)) + if (!string.IsNullOrWhiteSpace(processId) && string.IsNullOrWhiteSpace(process.State.RunId)) { - process = process with { State = process.State with { Id = processId } }; + process = process with { State = process.State with { RunId = processId } }; } DaprKernelProcessContext processContext = new(process, actorProxyFactory); - await processContext.StartWithEventAsync(initialEvent).ConfigureAwait(false); + await processContext.KeyedStartWithEventAsync(key, processId, initialEvent).ConfigureAwait(false); return processContext; } } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprMapInfo.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprMapInfo.cs index 06b3193f6691..f5f090b7ff2b 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprMapInfo.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprMapInfo.cs @@ -27,7 +27,7 @@ public KernelProcessMap ToKernelProcessMap() KernelProcessStepInfo processStepInfo = this.ToKernelProcessStepInfo(); if (this.State is not KernelProcessMapState state) { - throw new KernelException($"Unable to read state from map with name '{this.State.Name}' and Id '{this.State.Id}'."); + throw new KernelException($"Unable to read state from map with name '{this.State.StepId}' and Id '{this.State.RunId}'."); } KernelProcessStepInfo operationStep = diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessInfo.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessInfo.cs index 53553e2ece16..c19466f2a3c3 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessInfo.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessInfo.cs @@ -30,7 +30,7 @@ public KernelProcess ToKernelProcess() var processStepInfo = this.ToKernelProcessStepInfo(); if (this.State is not KernelProcessState state) { - throw new KernelException($"Unable to read state from process with name '{this.State.Name}' and Id '{this.State.Id}'."); + throw new KernelException($"Unable to read state from process with name '{this.State.StepId}' and Id '{this.State.RunId}'."); } List steps = []; @@ -48,6 +48,10 @@ public KernelProcess ToKernelProcess() { steps.Add(proxyStep.ToKernelProcessProxy()); } + else if (step is DaprAgentStepInfo agentStep) + { + steps.Add(agentStep.ToKernelProcessAgentStep()); + } else { steps.Add(step.ToKernelProcessStepInfo()); @@ -83,6 +87,10 @@ public static DaprProcessInfo FromKernelProcess(KernelProcess kernelProcess) { daprSteps.Add(DaprProxyInfo.FromKernelProxyInfo(proxyStep)); } + else if (step is KernelProcessAgentStep agentStep) + { + daprSteps.Add(DaprAgentStepInfo.FromKernelProcessAgentStep(agentStep)); + } else { daprSteps.Add(DaprStepInfo.FromKernelStepInfo(step)); diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessRunner.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessRunner.cs new file mode 100644 index 000000000000..9722fb904bef --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProcessRunner.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Threading.Tasks; + +namespace Microsoft.SemanticKernel; + +/// +/// A class that can run a process locally or in-process. +/// +public class DaprProcessRunner +{ + /// + /// Runs the specified process. + /// + /// + /// + public Task RunProcess(string id) + { + return Task.CompletedTask; + } +} diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProxyInfo.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProxyInfo.cs index 8e7dc7583b6e..173a159cc0f0 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProxyInfo.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprProxyInfo.cs @@ -27,7 +27,7 @@ public KernelProcessProxy ToKernelProcessProxy() KernelProcessStepInfo processStepInfo = this.ToKernelProcessStepInfo(); if (this.State is not KernelProcessStepState state) { - throw new KernelException($"Unable to read state from proxy with name '{this.State.Name}', Id '{this.State.Id}' and type {this.State.GetType()}."); + throw new KernelException($"Unable to read state from proxy with name '{this.State.StepId}', Id '{this.State.RunId}' and type {this.State.GetType()}."); } return new KernelProcessProxy(state, this.Edges) diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprStepInfo.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprStepInfo.cs index 15b72d76744d..14ee386aa699 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/DaprStepInfo.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/DaprStepInfo.cs @@ -17,9 +17,11 @@ namespace Microsoft.SemanticKernel; [KnownType(typeof(DaprProcessInfo))] [KnownType(typeof(DaprMapInfo))] [KnownType(typeof(DaprProxyInfo))] +[KnownType(typeof(DaprAgentStepInfo))] [JsonDerivedType(typeof(DaprProcessInfo))] [JsonDerivedType(typeof(DaprMapInfo))] [JsonDerivedType(typeof(DaprProxyInfo))] +[JsonDerivedType(typeof(DaprAgentStepInfo))] public record DaprStepInfo { /// diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IAgentStep.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IAgentStep.cs new file mode 100644 index 000000000000..6aef3cef8237 --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IAgentStep.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft. All rights reserved. +using System.Threading.Tasks; +using Dapr.Actors; + +namespace Microsoft.SemanticKernel; + +/// +/// An interface that represents an agent step in a process. +/// +public interface IAgentStep : IActor +{ + /// + /// Initializes the step with the provided step information. + /// + /// A + /// + Task InitializeAgentStepAsync(string processId, string stepId, string? parentProcessId); +} diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IDictionary.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IDictionary.cs new file mode 100644 index 000000000000..910f766c6346 --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IDictionary.cs @@ -0,0 +1,7 @@ +// Copyright (c) Microsoft. All rights reserved. + +namespace Microsoft.SemanticKernel; + +public interface IDictionary +{ +} \ No newline at end of file diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IMap.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IMap.cs index 483a6bc3502a..c1afbe25784c 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IMap.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IMap.cs @@ -14,5 +14,5 @@ public interface IMap : IActor /// /// A /// - Task InitializeMapAsync(DaprMapInfo mapInfo, string? parentProcessId); + Task InitializeMapAsync(string processId, string stepId); } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProcess.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProcess.cs index 8a4ce788b51d..069ebce993a3 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProcess.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProcess.cs @@ -1,5 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; using System.Threading.Tasks; using Dapr.Actors; @@ -13,11 +14,22 @@ public interface IProcess : IActor, IStep /// /// Initializes the process with the specified instance of . /// - /// Used to initialize the process. + /// Used to indicate the process that should be initialized. /// The parent Id of the process if one exists. /// An optional identifier of an actor requesting to proxy events. /// A - Task InitializeProcessAsync(DaprProcessInfo processInfo, string? parentProcessId, string? eventProxyStepId); + Task InitializeProcessAsync(string processKey, string? parentProcessId, string? eventProxyStepId); + + /// + /// Initializes the process with the specified process key. + /// + /// + /// + /// + /// + /// + /// + Task KeyedRunOnceAsync(string processKey, string processId, string parentProcessId, string? eventProxyStepId, string processEvent); /// /// Starts an initialized process. @@ -52,5 +64,5 @@ public interface IProcess : IActor, IStep /// Gets the process information. /// /// An instance of - Task GetProcessInfoAsync(); + Task> GetProcessInfoAsync(); } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProxy.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProxy.cs index 786fe7db49b2..d55772c84a84 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProxy.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IProxy.cs @@ -14,5 +14,5 @@ public interface IProxy : IActor /// /// A /// - Task InitializeProxyAsync(DaprProxyInfo proxyInfo, string? parentProcessId); + Task InitializeProxyAsync(string processId, string stepId, string? parentProcessId); } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IStep.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IStep.cs index 1cac1d945217..4b9b61f41403 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IStep.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Interfaces/IStep.cs @@ -1,5 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; using System.Threading.Tasks; using Dapr.Actors; @@ -15,7 +16,7 @@ public interface IStep : IActor /// /// A /// - Task InitializeStepAsync(DaprStepInfo stepInfo, string? parentProcessId, string? eventProxyStepId); + Task InitializeStepAsync(string processId, string stepId, string? parentProcessId, string? eventProxyStepId); /// /// Triggers the step to dequeue all pending messages and prepare for processing. @@ -33,5 +34,5 @@ public interface IStep : IActor /// Builds the current state of the step into a . /// /// An instance of - Task ToDaprStepInfoAsync(); + Task> GetStepStateAsync(); } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/KernelProcessDaprExtensions.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/KernelProcessDaprExtensions.cs index 504895e463fd..1fe4f4683ce2 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/KernelProcessDaprExtensions.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/KernelProcessDaprExtensions.cs @@ -1,6 +1,9 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; using Dapr.Actors.Runtime; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.SemanticKernel.Process; namespace Microsoft.SemanticKernel; @@ -20,9 +23,40 @@ public static void AddProcessActors(this ActorRuntimeOptions actorOptions) actorOptions.Actors.RegisterActor(); actorOptions.Actors.RegisterActor(); actorOptions.Actors.RegisterActor(); + actorOptions.Actors.RegisterActor(); actorOptions.Actors.RegisterActor(); actorOptions.Actors.RegisterActor(); actorOptions.Actors.RegisterActor(); actorOptions.Actors.RegisterActor(); } + + /// + /// Adds the Dapr process runtime to the service collection. + /// + /// + public static void AddDaprKernelProcesses(this IServiceCollection sc) + { + sc.AddSingleton(); + RegisterKeyedProcesses(sc); + } + + /// + /// Registers the keyed processes in the service collection. + /// + /// + private static void RegisterKeyedProcesses(this IServiceCollection sc) + { + // KeyedServiceCache caches all the keys of a given type for a + // specific service type. By making it a singleton we only have + // determine the keys once, which makes resolving the dict very fast. + sc.AddSingleton(); + + // KeyedServiceCache depends on the IServiceCollection to get + // the list of keys. That's why we register that here as well, as it + // is not registered by default in MS.DI. + sc.AddSingleton(sc); + + // For completeness, let's also allow IReadOnlyDictionary to be resolved. + sc.AddTransient, KeyedServiceDictionary>(); + } } diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/KeyedProcesses.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/KeyedProcesses.cs new file mode 100644 index 000000000000..10b055b50245 --- /dev/null +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/KeyedProcesses.cs @@ -0,0 +1,49 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using Microsoft.Extensions.DependencyInjection; + +namespace Microsoft.SemanticKernel.Process; + +/// +/// A collection of all the registered services with associated keys +/// +/// The +public sealed class KeyedProcesses(IServiceCollection sc) +{ + /// + /// The keys of all the registered services + /// + public IReadOnlyList Keys { get; } = [.. + from service in sc + where service.ServiceKey != null + where service.ServiceKey!.GetType() == typeof(string) + where service.ServiceType == typeof(KernelProcess) + select (string)service.ServiceKey!]; +} + +/// +/// A dictionary of all the keys for the services +/// +/// +/// +public sealed class KeyedServiceDictionary( + KeyedProcesses keys, IServiceProvider provider) + : ReadOnlyDictionary(Create(keys, provider)) +{ + private static Dictionary Create( + KeyedProcesses keys, IServiceProvider provider) + { + var dict = new Dictionary(capacity: keys.Keys.Count); + + foreach (string key in keys.Keys) + { + dict[key] = provider.GetRequiredKeyedService(key); + } + + return dict; + } +} diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Process.Runtime.Dapr.csproj b/dotnet/src/Experimental/Process.Runtime.Dapr/Process.Runtime.Dapr.csproj index 8ba7b61f4c8e..3dec07efe64d 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Process.Runtime.Dapr.csproj +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Process.Runtime.Dapr.csproj @@ -17,7 +17,8 @@ Semantic Kernel Process - Dapr Runtime - Semantic Kernel Process Dapr Runtime. This package is automatically installed by Semantic Kernel Process packages if needed. + Semantic Kernel Process Dapr Runtime. This package is automatically installed by + Semantic Kernel Process packages if needed. diff --git a/dotnet/src/Experimental/Process.Runtime.Dapr/Serialization/KernelProcessEventSerializer.cs b/dotnet/src/Experimental/Process.Runtime.Dapr/Serialization/KernelProcessEventSerializer.cs index c77becb9f6f1..437a68672d4c 100644 --- a/dotnet/src/Experimental/Process.Runtime.Dapr/Serialization/KernelProcessEventSerializer.cs +++ b/dotnet/src/Experimental/Process.Runtime.Dapr/Serialization/KernelProcessEventSerializer.cs @@ -18,6 +18,7 @@ internal static class KernelProcessEventSerializer /// public static string ToJson(this KernelProcessEvent processEvent) { + //var wrappedEvent = processEvent with { Data = KernelProcessEventData.FromObject(processEvent.Data) }; // TODO: Is this needed for Map Step? EventContainer containedEvents = new(TypeInfo.GetAssemblyQualifiedType(processEvent.Data), processEvent); return JsonSerializer.Serialize(containedEvents); } diff --git a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessBuilderTests.cs b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessBuilderTests.cs index 26c2fc9b0e7e..0fca9e58243f 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessBuilderTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessBuilderTests.cs @@ -25,7 +25,7 @@ public void ProcessBuilderInitialization() var processBuilder = new ProcessBuilder(ProcessName); // Assert - Assert.Equal(ProcessName, processBuilder.Name); + Assert.Equal(ProcessName, processBuilder.StepId); Assert.Empty(processBuilder.Steps); } @@ -43,7 +43,7 @@ public void AddStepFromTypeAddsStep() // Assert Assert.Single(processBuilder.Steps); - Assert.Equal(StepName, stepBuilder.Name); + Assert.Equal(StepName, stepBuilder.StepId); } /// @@ -84,7 +84,7 @@ public void AddStepFromProcessAddsSubProcess() // Assert Assert.Single(processBuilder.Steps); - Assert.Equal(SubProcessName, stepBuilder.Name); + Assert.Equal(SubProcessName, stepBuilder.StepId); } /// @@ -143,7 +143,7 @@ public void BuildCreatesKernelProcess() // Assert Assert.NotNull(kernelProcess); - Assert.Equal(ProcessName, kernelProcess.State.Name); + Assert.Equal(ProcessName, kernelProcess.State.StepId); Assert.Single(kernelProcess.Steps); } diff --git a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessMapBuilderTests.cs b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessMapBuilderTests.cs index d62b54646bcd..b883ba7f96cc 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessMapBuilderTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessMapBuilderTests.cs @@ -24,9 +24,9 @@ public void ProcessMapBuilderFromStep() ProcessMapBuilder map = new(step); // Assert - Assert.NotNull(map.Id); - Assert.NotNull(map.Name); - Assert.Contains(nameof(SimpleTestStep), map.Name); + Assert.NotNull(map.StepId); + Assert.NotNull(map.StepId); + Assert.Contains(nameof(SimpleTestStep), map.StepId); Assert.NotNull(map.MapOperation); Assert.Equal(step, map.MapOperation); } @@ -61,9 +61,9 @@ public void ProcessMapBuilderFromProcess() ProcessMapBuilder map = new(process); // Assert - Assert.NotNull(map.Id); - Assert.NotNull(map.Name); - Assert.Contains(process.Name, map.Name); + Assert.NotNull(map.StepId); + Assert.NotNull(map.StepId); + Assert.Contains(process.StepId, map.StepId); Assert.NotNull(map.MapOperation); Assert.Equal(process, map.MapOperation); } @@ -95,7 +95,7 @@ public void ProcessMapBuilderCanDefineTarget() Assert.NotNull(processMap); Assert.Equal(processMap.Edges.Count, map.Edges.Count); Assert.Equal(processMap.Edges.Single().Value.Count, map.Edges.First().Value.Count); - Assert.Equal((processMap.Edges.Single().Value.Single().OutputTarget as KernelProcessFunctionTarget)!.StepId, (map.Edges.Single().Value[0].Target as ProcessFunctionTargetBuilder)!.Step.Id); + Assert.Equal((processMap.Edges.Single().Value.Single().OutputTarget as KernelProcessFunctionTarget)!.StepId, (map.Edges.Single().Value[0].Target as ProcessFunctionTargetBuilder)!.Step.StepId); } /// @@ -129,8 +129,8 @@ public void ProcessMapBuilderWillBuild() // Assert Assert.NotNull(processMap); Assert.IsType(processMap); - Assert.Equal(map.Name, processMap.State.Name); - Assert.Equal(map.Id, processMap.State.Id); + Assert.Equal(map.StepId, processMap.State.StepId); + Assert.Equal(map.StepId, processMap.State.RunId); } /// diff --git a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessProxyBuilderTests.cs b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessProxyBuilderTests.cs index e8f78b9daeaf..9a9418204975 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessProxyBuilderTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessProxyBuilderTests.cs @@ -26,9 +26,9 @@ public void ProcessProxyBuilderInitialization() ProcessProxyBuilder proxy = new([this._topicName1, this._topicName2, this._topicName3], this._proxyName, null); // Assert - Assert.NotNull(proxy.Id); - Assert.NotNull(proxy.Name); - Assert.Equal(this._proxyName, proxy.Name); + Assert.NotNull(proxy.StepId); + Assert.NotNull(proxy.StepId); + Assert.Equal(this._proxyName, proxy.StepId); Assert.True(proxy._externalTopicUsage.Count > 0); } @@ -78,8 +78,8 @@ public void ProcessProxyBuilderWillBuild() // Assert Assert.NotNull(proxyInfo); Assert.IsType(proxyInfo); - Assert.Equal(proxy.Name, proxyInfo.State.Name); - Assert.Equal(proxy.Id, proxyInfo.State.Id); + Assert.Equal(proxy.StepId, proxyInfo.State.StepId); + Assert.Equal(proxy.StepId, proxyInfo.State.RunId); var processProxy = (KernelProcessProxy)proxyInfo; Assert.NotNull(processProxy?.ProxyMetadata); Assert.Equal(proxy._eventMetadata, processProxy.ProxyMetadata.EventMetadata); diff --git a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepBuilderTests.cs b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepBuilderTests.cs index 8131d345ce2a..2518491b99f0 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepBuilderTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepBuilderTests.cs @@ -1,7 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. using System.Collections.Generic; -using Microsoft.SemanticKernel.Process.Models; using Xunit; namespace Microsoft.SemanticKernel.Process.Core.UnitTests; @@ -24,8 +23,8 @@ public void ConstructorShouldInitializeProperties() var stepBuilder = new TestProcessStepBuilder(name); // Assert - Assert.Equal(name, stepBuilder.Name); - Assert.NotNull(stepBuilder.Id); + Assert.Equal(name, stepBuilder.StepId); + Assert.NotNull(stepBuilder.StepId); Assert.NotNull(stepBuilder.FunctionsDict); Assert.NotNull(stepBuilder.Edges); } @@ -235,9 +234,9 @@ private sealed class TestProcessStepBuilder : ProcessStepBuilder { public TestProcessStepBuilder(string name) : base(name, null) { } - internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder, KernelProcessStepStateMetadata? stateMetadata = null) + internal override KernelProcessStepInfo BuildStep(ProcessBuilder processBuilder) { - return new KernelProcessStepInfo(typeof(TestProcessStepBuilder), new KernelProcessStepState(this.Name, version: "v1", id: this.Id), []); + return new KernelProcessStepInfo(typeof(TestProcessStepBuilder), new KernelProcessStepState(this.StepId, version: "v1", runId: this.StepId), []); } internal override Dictionary GetFunctionMetadataMap() diff --git a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepEdgeBuilderTests.cs b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepEdgeBuilderTests.cs index fb854d873625..7c2db619d417 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepEdgeBuilderTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Core/ProcessStepEdgeBuilderTests.cs @@ -139,7 +139,7 @@ public void BuildShouldReturnKernelProcessEdge() // Assert Assert.NotNull(edge); - Assert.Equal(source.Id, edge.SourceStepId); + Assert.Equal(source.StepId, edge.SourceStepId); } /// diff --git a/dotnet/src/Experimental/Process.UnitTests/KernelProcessProxyTests.cs b/dotnet/src/Experimental/Process.UnitTests/KernelProcessProxyTests.cs index 5c5589ec60bb..5a5bed1cd64a 100644 --- a/dotnet/src/Experimental/Process.UnitTests/KernelProcessProxyTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/KernelProcessProxyTests.cs @@ -33,8 +33,8 @@ public void KernelProcessProxyStateInitialization() public void KernelProcessProxyStateRequiredProperties() { // Act & Assert - Assert.Throws(() => new KernelProcessStepState(name: null!, "vTest", "testid")); - Assert.Throws(() => new KernelProcessStepState(name: "testname", null!, "testid")); + Assert.Throws(() => new KernelProcessStepState(stepId: null!, "vTest", "testid")); + Assert.Throws(() => new KernelProcessStepState(stepId: "testname", null!, "testid")); Assert.Throws(() => new KernelProcessProxy(new KernelProcessStepState("testname", "vTest", null!), [])); } } diff --git a/dotnet/src/Experimental/Process.UnitTests/KernelProcessSerializationTests.cs b/dotnet/src/Experimental/Process.UnitTests/KernelProcessSerializationTests.cs index dbb21073ca00..4d5bb3f3cea6 100644 --- a/dotnet/src/Experimental/Process.UnitTests/KernelProcessSerializationTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/KernelProcessSerializationTests.cs @@ -46,7 +46,7 @@ public void KernelProcessSerialization() ProcessBuilder anotherBuilder = new(nameof(KernelProcessSerialization)); anotherBuilder.AddStepFromType("SimpleStep"); anotherBuilder.AddStepFromType("StatefulStep"); - KernelProcess another = anotherBuilder.Build(copyState); + KernelProcess another = anotherBuilder.Build(); AssertProcess(process, another); } @@ -85,7 +85,7 @@ public void KernelSubProcessSerialization() anotherSubBuilder.AddStepFromType("SimpleStep"); anotherSubBuilder.AddStepFromType("StatefulStep"); anotherBuilder.AddStepFromProcess(anotherSubBuilder); - KernelProcess another = anotherBuilder.Build(copyState); + KernelProcess another = anotherBuilder.Build(); AssertProcess(process, another); } @@ -117,14 +117,14 @@ public void KernelProcessMapSerialization() // Arrange ProcessBuilder anotherBuilder = new(nameof(KernelProcessSerialization)); anotherBuilder.AddMapStepFromType("StatefulStep"); - KernelProcess another = anotherBuilder.Build(copyState); + KernelProcess another = anotherBuilder.Build(); AssertProcess(process, another); } private static void AssertProcess(KernelProcess expectedProcess, KernelProcess anotherProcess) { - Assert.Equal(expectedProcess.State.Name, anotherProcess.State.Name); + Assert.Equal(expectedProcess.State.StepId, anotherProcess.State.StepId); Assert.Equal(expectedProcess.State.Version, anotherProcess.State.Version); Assert.Equal(expectedProcess.Steps.Count, anotherProcess.Steps.Count); @@ -137,7 +137,7 @@ private static void AssertProcess(KernelProcess expectedProcess, KernelProcess a private static void AssertStep(KernelProcessStepInfo expectedStep, KernelProcessStepInfo actualStep) { Assert.Equal(expectedStep.InnerStepType, actualStep.InnerStepType); - Assert.Equal(expectedStep.State.Name, actualStep.State.Name); + Assert.Equal(expectedStep.State.StepId, actualStep.State.StepId); Assert.Equal(expectedStep.State.Version, actualStep.State.Version); if (expectedStep is KernelProcessMap mapStep) @@ -156,15 +156,15 @@ private static void AssertStep(KernelProcessStepInfo expectedStep, KernelProcess KernelProcessStepState actualState = (KernelProcessStepState)actualStep.State; Assert.NotNull(stepState.State); Assert.NotNull(actualState.State); - Assert.Equal(stepState.State.Id, actualState.State.Id); + //Assert.Equal(stepState.State.Id, actualState.State.Id); } } private static void AssertProcessState(KernelProcess process, KernelProcessStateMetadata? savedProcess) { Assert.NotNull(savedProcess); - Assert.Equal(process.State.Id, savedProcess.Id); - Assert.Equal(process.State.Name, savedProcess.Name); + Assert.Equal(process.State.RunId, savedProcess.Id); + Assert.Equal(process.State.StepId, savedProcess.Name); Assert.Equal(process.State.Version, savedProcess.VersionInfo); Assert.NotNull(savedProcess.StepsState); Assert.Equal(process.Steps.Count, savedProcess.StepsState.Count); @@ -177,10 +177,10 @@ private static void AssertProcessState(KernelProcess process, KernelProcessState private static void AssertStepState(KernelProcessStepInfo step, Dictionary savedSteps) { - Assert.True(savedSteps.ContainsKey(step.State.Name)); - KernelProcessStepStateMetadata savedStep = savedSteps[step.State.Name]; - Assert.Equal(step.State.Id, savedStep.Id); - Assert.Equal(step.State.Name, savedStep.Name); + Assert.True(savedSteps.ContainsKey(step.State.StepId)); + KernelProcessStepStateMetadata savedStep = savedSteps[step.State.StepId]; + Assert.Equal(step.State.RunId, savedStep.Id); + Assert.Equal(step.State.StepId, savedStep.Name); Assert.Equal(step.State.Version, savedStep.VersionInfo); if (step is KernelProcessMap mapStep) diff --git a/dotnet/src/Experimental/Process.UnitTests/KernelProcessStateTests.cs b/dotnet/src/Experimental/Process.UnitTests/KernelProcessStateTests.cs index c20509037a99..9fde929fca0a 100644 --- a/dotnet/src/Experimental/Process.UnitTests/KernelProcessStateTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/KernelProcessStateTests.cs @@ -24,8 +24,8 @@ public void KernelProcessStateInitializationSetsPropertiesCorrectly() KernelProcessState state = new(name, "v1", id); // Assert - Assert.Equal(name, state.Name); - Assert.Equal(id, state.Id); + Assert.Equal(name, state.StepId); + Assert.Equal(id, state.RunId); } /// @@ -41,8 +41,8 @@ public void KernelProcessStateInitializationWithNullIdSucceeds() KernelProcessState state = new(name, version: "v1"); // Assert - Assert.Equal(name, state.Name); - Assert.Null(state.Id); + Assert.Equal(name, state.StepId); + Assert.Null(state.RunId); } /// diff --git a/dotnet/src/Experimental/Process.UnitTests/ProcessSerializationTests.cs b/dotnet/src/Experimental/Process.UnitTests/ProcessSerializationTests.cs index a073c47b2a13..56fad66f3f73 100644 --- a/dotnet/src/Experimental/Process.UnitTests/ProcessSerializationTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/ProcessSerializationTests.cs @@ -47,10 +47,10 @@ public async Task KernelProcessFromDotnetOnlyWorkflow1YamlAsync() // Assert Assert.NotNull(process); - var stepKickoff = process.Steps.FirstOrDefault(s => s.State.Id == "kickoff"); - var stepA = process.Steps.FirstOrDefault(s => s.State.Id == "a_step"); - var stepB = process.Steps.FirstOrDefault(s => s.State.Id == "b_step"); - var stepC = process.Steps.FirstOrDefault(s => s.State.Id == "c_step"); + var stepKickoff = process.Steps.FirstOrDefault(s => s.State.StepId == "kickoff"); + var stepA = process.Steps.FirstOrDefault(s => s.State.StepId == "a_step"); + var stepB = process.Steps.FirstOrDefault(s => s.State.StepId == "b_step"); + var stepC = process.Steps.FirstOrDefault(s => s.State.StepId == "c_step"); Assert.NotNull(stepKickoff); Assert.NotNull(stepA); @@ -115,7 +115,7 @@ public async Task KernelProcessFromScenario1YamlAsync() /// Verify that the process can be serialized to YAML and deserialized back to a workflow. /// /// - [Fact] + [Fact(Skip = "Process Builder no longer has .State.Id assigned, it should be assigned in the next layer ex: Local components")] public async Task ProcessToWorkflowWorksAsync() { var process = this.GetProcess(); @@ -139,8 +139,8 @@ public async Task KernelProcessFromCombinedWorkflowYamlAsync() // Assert Assert.NotNull(process); - Assert.Contains(process.Steps, step => step.State.Id == "GetProductInfo"); - Assert.Contains(process.Steps, step => step.State.Id == "Summarize"); + Assert.Contains(process.Steps, step => step.State.StepId == "GetProductInfo"); + Assert.Contains(process.Steps, step => step.State.StepId == "Summarize"); } private KernelProcess GetProcess() diff --git a/dotnet/src/Experimental/Process.UnitTests/Resources/combined-workflow.yaml b/dotnet/src/Experimental/Process.UnitTests/Resources/combined-workflow.yaml index 5934688bab80..226db50000ef 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Resources/combined-workflow.yaml +++ b/dotnet/src/Experimental/Process.UnitTests/Resources/combined-workflow.yaml @@ -1,11 +1,11 @@ workflow: - id: combined_workflow + id: combined_workflow name: ProductSummarization inputs: events: cloud_events: - type: input_message_received - data_schema: + data_schema: type: string nodes: - id: GetProductInfo @@ -33,7 +33,7 @@ workflow: - event_type: ProcessCompleted orchestration: - listen_for: - event: input_message_received + event: input_message_received from: _workflow_ then: - node: GetProductInfo diff --git a/dotnet/src/Experimental/Process.UnitTests/Resources/dotnetOnlyWorkflow1.yaml b/dotnet/src/Experimental/Process.UnitTests/Resources/dotnetOnlyWorkflow1.yaml index 4b7466b80038..bae73819697c 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Resources/dotnetOnlyWorkflow1.yaml +++ b/dotnet/src/Experimental/Process.UnitTests/Resources/dotnetOnlyWorkflow1.yaml @@ -16,10 +16,10 @@ inputs: # The structured inputs supported by the workflow. events: cloud_events: - type: "StartRequested" - data_schema: + data_schema: type: string - type: "StartARequested" - data_schema: + data_schema: type: string # Schemas for the data types used in the workflow. These can be defined inline or referenced from an external schema. @@ -73,8 +73,8 @@ nodes: expression: "results.articles.length > '0'" emits: - event_type: data_fetched - schema: - $ref: "#/workflow/schemas/research_data" + schema: + $ref: "#/workflow/schemas/research_data" payload: "$agent.outputs.results" - on_condition: type: default @@ -89,7 +89,7 @@ nodes: research_data: schema: $ref: "#/workflow/schemas/research_data" - last_feedback: + last_feedback: type: string agent: type: "Microsoft.SemanticKernel.Process.UnitTests.Steps.AStep, SemanticKernel.Process.UnitTests" @@ -99,8 +99,8 @@ nodes: type: default emits: - event_type: draft_created - schema: - $ref: "#/workflow/schemas/draft" + schema: + $ref: "#/workflow/schemas/draft" payload: "$agent.outputs.draft" - id: b_step @@ -116,7 +116,7 @@ nodes: expression: "report_feedback.passed == 'true'" emits: - event_type: report_approved - schema: + schema: $ref: "#/workflow/schemas/report" payload: object: @@ -126,7 +126,7 @@ nodes: type: default emits: - event_type: report_rejected - schema: + schema: $ref: "#/workflow/schemas/report_feedback" payload: "$agent.outputs.report_feedback" updates: @@ -141,7 +141,7 @@ nodes: type: dotnet version: "1.0" description: "C Step" - agent: + agent: type: "Microsoft.SemanticKernel.Process.UnitTests.Steps.CStep, SemanticKernel.Process.UnitTests" id: c_step_agent # inputs: @@ -154,19 +154,18 @@ nodes: type: default emits: - event_type: human_approved - schema: + schema: $ref: "#/workflow/schemas/report" updates: - - variable: approved_report - operation: set - value: "$agent.outputs.report" - - variable: $workflow.thread - operation: set - value: "$agent.outputs.report" + - variable: approved_report + operation: set + value: "$agent.outputs.report" + - variable: $workflow.thread + operation: set + value: "$agent.outputs.report" # The orchestration of the workflow. This defines the sequence of events and actions that make up the workflow. orchestration: - - listen_for: event: "StartRequested" from: _workflow_ @@ -182,16 +181,16 @@ orchestration: - listen_for: all_of: - - event: "AStepDone" - from: a_step - - event: "BStepDone" - from: b_step + - event: "AStepDone" + from: a_step + - event: "BStepDone" + from: b_step then: - node: c_step inputs: aStepData: a_step.AStepDone bStepData: b_step.BStepDone - + - listen_for: event: "CStepDone" from: c_step diff --git a/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalMapTests.cs b/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalMapTests.cs index 634ec8a08f48..46f8aa617d1e 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalMapTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalMapTests.cs @@ -284,7 +284,7 @@ public async Task ProcessMapResultWithTargetInvalidAsync() /// Validates the result an extra edge is /// introduced to the map-operation. /// - [Fact] + [Fact(Skip = "Test failing intermittently")] public async Task ProcessMapResultWithTargetExtraAsync() { // Arrange @@ -387,7 +387,7 @@ await process.StartAsync( private static async Task GetUnionStateAsync(LocalKernelProcessContext processContext) { KernelProcess processState = await processContext.GetStateAsync(); - KernelProcessStepState unionState = (KernelProcessStepState)processState.Steps.Single(s => s.State.Name == "Union").State; + KernelProcessStepState unionState = (KernelProcessStepState)processState.Steps.Single(s => s.State.StepId == "Union").State; Assert.NotNull(unionState); Assert.NotNull(unionState.State); return unionState.State; diff --git a/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProcessTests.cs b/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProcessTests.cs index 770eab991394..ee372bc1ac88 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProcessTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProcessTests.cs @@ -1,7 +1,15 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Collections.Generic; +using System.Linq; +using System.Text.Json; using System.Threading.Tasks; +using Microsoft.SemanticKernel.Process.Models.Storage; +using SemanticKernel.Process.TestsShared.Services; +using SemanticKernel.Process.TestsShared.Services.Storage; +using SemanticKernel.Process.TestsShared.Setup; +using SemanticKernel.Process.TestsShared.Steps; using Xunit; namespace Microsoft.SemanticKernel.Process.Runtime.Local.UnitTests; @@ -11,6 +19,8 @@ namespace Microsoft.SemanticKernel.Process.Runtime.Local.UnitTests; /// public class LocalProcessTests { + private readonly IReadOnlyDictionary _keyedProcesses = CommonProcesses.GetCommonProcessesKeyedDictionary(); + /// /// Validates that the constructor initializes the steps correctly. /// @@ -65,8 +75,9 @@ public async Task ProcessWithMissingIdIsAssignedAnIdAsync() public async Task ProcessWithAssignedIdIsNotOverwrittenIdAsync() { // Arrange + var processId = "AlreadySet"; var mockKernel = new Kernel(); - var processState = new KernelProcessState(name: "TestProcess", version: "v1", id: "AlreadySet"); + var processState = new KernelProcessState(name: "TestProcess", version: "v1"); var mockKernelProcess = new KernelProcess(processState, [ new(typeof(TestStep), new KernelProcessState(name: "Step1", version: "v1", id: "1"), []), @@ -74,7 +85,7 @@ public async Task ProcessWithAssignedIdIsNotOverwrittenIdAsync() ], []); // Act - await using var localProcess = new LocalProcess(mockKernelProcess, mockKernel); + await using var localProcess = new LocalProcess(mockKernelProcess, mockKernel, instanceId: processId); // Assert Assert.NotEmpty(localProcess.Id); @@ -161,6 +172,409 @@ public async Task FunctionErrorHandlerTakesPrecedenceAsync() Assert.IsType(kernel.Data["error-function"]); } + /// + /// Verify that the process level error handler is called when a function fails. + /// + /// + [Fact] + public async Task StartProcessWithKeyedProcessDictFailDueMissingKeyAsync() + { + // Arrange + var processId = "myProcessId"; + var processKey = "someKeyThatDoesNotExist"; + + CounterService counterService = new(); + Kernel kernel = KernelSetup.SetupKernelWithCounterService(counterService); + + // Act & Assert + try + { + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + }); + } + catch (ArgumentException ex) + { + // Assert + Assert.Equal($"The process with key '{processKey}' is not registered.", ex.Message); + } + } + + /// + /// Verify that the process runs correctly when using the context factory with process key. + /// + /// + [Fact] + public async Task StartProcessWithKeyedProcessDictSuccessfullyAsync() + { + // Arrange + var processId = "myProcessId"; + var processKey = CommonProcesses.ProcessKeys.CounterProcess; + + CounterService counterService = new(); + Kernel kernel = KernelSetup.SetupKernelWithCounterService(counterService); + + // Act + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + }); + + // Assert + var processState = await runningProcess.GetStateAsync(); + Assert.NotNull(processState); + Assert.Equal(processKey, processState.State.StepId); + Assert.Equal(processId, processState.State.RunId); + } + + /// + /// Verify that the process runs correctly when using the context factory with process key and a storage manager. + /// + /// + [Fact] + public async Task StartProcessWithKeyedProcessDictAndStoreManagerAsync() + { + // Arrange + var processId = "myProcessId"; + var processKey = CommonProcesses.ProcessKeys.CounterProcess; + var counterName = "counterStep"; + + var processStorage = new MockStorage(); + + CounterService counterService = new(); + Kernel kernel = KernelSetup.SetupKernelWithCounterService(counterService); + + // Act - 1 + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + }, storageConnector: processStorage); + + // Assert - 1 + var processState = await runningProcess.GetStateAsync(); + Assert.NotNull(processState); + var counterState = processState.Steps.Where(s => s.State.StepId == counterName).FirstOrDefault(); + Assert.NotNull(counterState); + Assert.Equal(1, ((KernelProcessStepState)counterState.State).State?.Count); + + Assert.Equal(processKey, processState.State.StepId); + Assert.Equal(processId, processState.State.RunId); + + // Act - 2 + counterService.SetCount(0); + await using LocalKernelProcessContext runningProcess2 = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + }, storageConnector: processStorage); + + // Assert - 2 + var processState2 = await runningProcess2.GetStateAsync(); + Assert.NotNull(processState2); + var counterState2 = processState2.Steps.Where(s => s.State.StepId == counterName).FirstOrDefault(); + Assert.NotNull(counterState2); + Assert.Equal(2, ((KernelProcessStepState)counterState2.State).State?.Count); + + Assert.Equal(processKey, processState2.State.StepId); + Assert.Equal(processId, processState2.State.RunId); + } + + /// + /// Verify that the process runs correctly when using the context factory with process key and a storage manager. + /// Running same process twice to verify step parameters get persisted. + /// + /// + [Fact] + public async Task StartProcessWithKeyedProcessAndUseOfAllOfAsync() + { + // Arrange + var processId = "myProcessId"; + var mergeStepStorageEntry = "{0}.MergeStringsStep.StepDetails"; + var processKey = CommonProcesses.ProcessKeys.DelayedMergeProcess; + + var processStorage = new MockStorage(); + // To use local storage, comment line above and uncomment line below + replacing with existing directory path + //var processStorage = new JsonFileStorage(""); + + CounterService counterService = new(); + Kernel kernel = KernelSetup.SetupKernelWithCounterService(counterService); + + // Act - 1 + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + Data = "Hello", + }, storageConnector: processStorage); + + // Assert - 1 + var processState = await runningProcess.GetStateAsync(); + Assert.NotNull(processState); + Assert.Equal(processId, processState.State.RunId); + var mergeStepId = processState.Steps.Where(s => s.State.StepId == "MergeStringsStep").FirstOrDefault()?.State.RunId; + Assert.NotNull(mergeStepId); + var mergeStepFullEntry = string.Format(mergeStepStorageEntry, mergeStepId); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var entry); + Assert.NotNull(entry?.Content); + + var edgeData = JsonSerializer.Deserialize(entry.Content); + Assert.NotNull(edgeData?.StepEvents?.EdgesData); + Assert.Single(edgeData.StepEvents.EdgesData); + // Only 2/3 events in merge step should have arrived and persisted in stepEdgesData + Assert.Equal(2, edgeData.StepEvents.EdgesData.First().Value?.Count); + Assert.True(edgeData.StepEvents.EdgesData.First().Value?.ContainsKey("DelayedEchoStep22.DelayedEcho")); + Assert.True(edgeData.StepEvents.EdgesData.First().Value?.ContainsKey("DelayedEchoStep33.DelayedEcho")); + + // Act - 2 + await using LocalKernelProcessContext runningProcess2 = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.OtherEvent, + Data = "World", + }, storageConnector: processStorage); + + // Assert - 2 + var processState2 = await runningProcess2.GetStateAsync(); + Assert.NotNull(processState2); + Assert.Equal(processId, processState2.State.RunId); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var entry2); + Assert.NotNull(entry2?.Content); + Assert.IsType(entry2?.Content); + + var edgeData2 = JsonSerializer.Deserialize(entry2.Content); + Assert.NotNull(edgeData2?.StepEvents?.EdgesData); + Assert.Single(edgeData2.StepEvents.EdgesData); + // All parameters in merge step should have been processed and edge data should be empty + Assert.Empty(edgeData2.StepEvents.EdgesData.First().Value!); + } + + /// + /// Verify that the process runs correctly when using the context factory with process key and a storage manager. + /// Running same process twice to verify step parameters get persisted. + /// Making use of process input events directly to validate AllOf plumbing with process events + /// + /// + [Fact] + public async Task StartProcessWithKeyedProcessUseOfAllOfAndAllEventsAreProcessInputsAsync() + { + // Arrange + var processId = "myProcessId"; + var mergeStepStorageEntry = "{0}.MergeStringsStep.StepDetails"; + var processKey = CommonProcesses.ProcessKeys.SimpleMergeProcess; + + var processStorage = new MockStorage(); + // To use local storage, comment line above and uncomment line below + replacing with existing directory path + //var processStorage = new JsonFileStorage(""); + + Kernel kernel = new(); + + // Act - 1 + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + Data = "Hello", + }, storageConnector: processStorage); + + // Assert - 1 + var processState = await runningProcess.GetStateAsync(); + Assert.NotNull(processState); + Assert.Equal(processId, processState.State.RunId); + var mergeStepId = processState.Steps.Where(s => s.State.StepId == "MergeStringsStep").FirstOrDefault()?.State.RunId; + Assert.NotNull(mergeStepId); + var mergeStepFullEntry = string.Format(mergeStepStorageEntry, mergeStepId); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var entry); + Assert.NotNull(entry?.Content); + Assert.IsType(entry?.Content); + + var edgeData = JsonSerializer.Deserialize(entry.Content); + Assert.NotNull(edgeData?.StepEvents?.EdgesData); + Assert.Single(edgeData.StepEvents.EdgesData); + // Only 1/2 events in merge step should have arrived and persisted in stepEdgesData + Assert.Single(edgeData.StepEvents.EdgesData.First().Value); + Assert.True(edgeData.StepEvents.EdgesData.First().Value?.ContainsKey("SimpleMergeProcess.StartProcess")); + + // Act - 2 + await using LocalKernelProcessContext runningProcess2 = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.OtherEvent, + Data = "World", + }, storageConnector: processStorage); + + // Assert - 2 + var processState2 = await runningProcess2.GetStateAsync(); + Assert.NotNull(processState2); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var entry2); + Assert.NotNull(entry2?.Content); + Assert.IsType(entry2?.Content); + + var edgeData2 = JsonSerializer.Deserialize(entry2.Content); + Assert.NotNull(edgeData2?.StepEvents?.EdgesData); + Assert.Single(edgeData2.StepEvents.EdgesData); + // All parameters in merge step should have been processed and edge data should be empty + Assert.Empty(edgeData2.StepEvents.EdgesData.First().Value!); + } + + [Fact] + public async Task StartProcessWithKeyedProcessUseOfNestedStatefulStepsAndAllOfAsync() + { + // Arrange + var processId = "myProcessId"; + var mergeStepStorageEntry = "{0}.MergeStringsStep.StepDetails"; + var outerCounterStorageEntry = "{0}.outerCounterStep.StepDetails"; + var innerCounterStorageEntry = "{0}.counterStep.StepDetails"; + var processKey = CommonProcesses.ProcessKeys.NestedCounterWithEvenDetectionAndMergeProcess; + + var processStorage = new MockStorage(); + // To use local storage, comment line above and uncomment line below + replacing with existing directory path + //var processStorage = new JsonFileStorage(""); + + Kernel kernel = new(); + var iterationCount = 4; + string? outerCounterStepFullEntry = null; + string? innerCounterStepFullEntry = null; + string? mergeStepFullEntry = null; + + for (int i = 1; i < iterationCount; i++) + { + // Act - 1,2,3 + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + }, storageConnector: processStorage); + + // Assert - 1,2,3 + var processState = await runningProcess.GetStateAsync(); + Assert.NotNull(processState); + Assert.Equal(processId, processState.State.RunId); + + outerCounterStepFullEntry ??= string.Format(outerCounterStorageEntry, processState.Steps.Where(s => s.State.StepId == "outerCounterStep").FirstOrDefault()?.State.RunId); + this.AssertCounterState(processStorage, outerCounterStepFullEntry, i); + + var innerCounterStepId = (processState.Steps.Where(s => s.State.StepId == "innerCounterProcess").FirstOrDefault() as KernelProcess)?.Steps.Where(s => s.State.StepId == "counterStep").FirstOrDefault()?.State.RunId; + if (i == 1) + { + Assert.Null(innerCounterStepId); + } + else + { + innerCounterStepFullEntry ??= string.Format(innerCounterStorageEntry, innerCounterStepId); + this.AssertCounterState(processStorage, innerCounterStepFullEntry, i / 2); + } + + // Merge Step entry should have parameter entries pending until iteration 4 + mergeStepFullEntry ??= string.Format(mergeStepStorageEntry, processState.Steps.Where(s => s.State.StepId == "MergeStringsStep").FirstOrDefault()?.State.RunId); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var mergeStorageEntry); + Assert.NotNull(mergeStorageEntry?.Content); + + var mergeEdgeData = JsonSerializer.Deserialize(mergeStorageEntry.Content); + Assert.NotNull(mergeEdgeData?.StepEvents?.EdgesData); + Assert.Single(mergeEdgeData.StepEvents.EdgesData); + Assert.NotEmpty(mergeEdgeData.StepEvents.EdgesData.Values); + } + + // Act - 4 + await using LocalKernelProcessContext runningProcess2 = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + }, storageConnector: processStorage); + + // Assert - 4 + var processState2 = await runningProcess2.GetStateAsync(); + Assert.NotNull(processState2); + Assert.Equal(processId, processState2.State.RunId); + + Assert.NotNull(outerCounterStepFullEntry); + this.AssertCounterState(processStorage, outerCounterStepFullEntry, 4); + + Assert.NotNull(innerCounterStepFullEntry); + this.AssertCounterState(processStorage, innerCounterStepFullEntry, 2); + + Assert.NotNull(mergeStepFullEntry); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var mergeStorageEntry2); + Assert.NotNull(mergeStorageEntry2?.Content); + + var mergeEdgeData2 = JsonSerializer.Deserialize(mergeStorageEntry2.Content); + Assert.NotNull(mergeEdgeData2?.StepEvents?.EdgesData); + Assert.Single(mergeEdgeData2.StepEvents.EdgesData); + Assert.Empty(mergeEdgeData2.StepEvents.EdgesData.Values.First()); + } + + private void AssertCounterState(MockStorage processStorage, string stepStorageEntry, int expectedCount) + { + processStorage._dbMock.TryGetValue(stepStorageEntry, out var outerCounterEntry); + Assert.NotNull(outerCounterEntry?.Content); + var outerCounterData = JsonSerializer.Deserialize(outerCounterEntry?.Content!); + Assert.NotNull(outerCounterData?.StepState?.State); + var counterStateData = outerCounterData.StepState.State.ToObject(); + Assert.NotNull(counterStateData); + Assert.IsType(counterStateData); + Assert.Equal(expectedCount, ((CommonSteps.CounterState)counterStateData).Count); + } + + [Fact] + public async Task StartProcessWithKeyedProcessUseOfInternalNestedStatefulStepsAndAllOfInternallyAndExternallyAsync() + { + // Arrange + var processId = "myProcessId"; + var mergeStepStorageEntry = "{0}.MergeStringsStep.StepDetails"; + var processKey = CommonProcesses.ProcessKeys.InternalNestedCounterWithEvenDetectionAndMergeProcess; + + var processStorage = new MockStorage(); + // To use local storage, comment line above and uncomment line below + replacing with existing directory path + //var processStorage = new JsonFileStorage(""); + + Kernel kernel = new(); + var iterationCount = 4; + + string? mergeStepFullEntry = null; + + for (int i = 1; i <= iterationCount; i++) + { + // Act - 1,2,3,4 + await using LocalKernelProcessContext runningProcess = await LocalKernelProcessFactory.StartAsync( + kernel, this._keyedProcesses, processKey, processId, new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + Data = i.ToString(), + }, storageConnector: processStorage); + + // Assert - 1,2,3,4 + var processState = await runningProcess.GetStateAsync(); + Assert.NotNull(processState); + Assert.Equal(processId, processState.State.RunId); + + mergeStepFullEntry ??= string.Format(mergeStepStorageEntry, processState.Steps.Where(s => s.State.StepId == "MergeStringsStep").FirstOrDefault()?.State.RunId); + processStorage._dbMock.TryGetValue(mergeStepFullEntry, out var mergeStorageEntry); + Assert.NotNull(mergeStorageEntry?.Content); + + var mergeEdgeData = JsonSerializer.Deserialize(mergeStorageEntry.Content); + Assert.NotNull(mergeEdgeData?.StepEvents?.EdgesData); + Assert.Single(mergeEdgeData.StepEvents.EdgesData); + Assert.Single(mergeEdgeData.StepEvents.EdgesData.Values); + if (i < 4) + { + // outer merge is waiting on missing parameters pending from internal nested subprocess + // in the meantime on each iteration, the only piped event/parameter keeps changing + Assert.Single(mergeEdgeData.StepEvents.EdgesData.Values.First().Values); + var firstEventValue = mergeEdgeData.StepEvents.EdgesData.Values.First().Values.First()?.ToObject(); + Assert.Equal(i.ToString(), firstEventValue?.ToString()); + } + else + { + // finally the missing event, that is piped for 2 parameters, arrived and now the merge edge data is empty since it was processed + Assert.Empty(mergeEdgeData.StepEvents.EdgesData.Values.First().Values); + } + } + } + /// /// A class that represents a step for testing. /// @@ -188,6 +602,308 @@ public void ProcessWithSubprocessAndInvalidTargetThrows() Kernel kernel = new(); } + /// + /// Process with branch that takes long time, other branch is short and needs external events. + /// Test helps validate persistence of external events received when process was already running but not ready to process them + /// + /// ┌──────────────────────────────┐ + /// │ │ + /// ┌──►│ delayed emitter ├─────┐ + /// │ │ │ │ + /// ┌────────┐ │ └──────────────────────────────┘ │ ┌─────────────┐ + /// │ ├───┘ │ │ │ + /// START ──────────►│ echo │ └─►│ dual echo │ + /// PROCESS │ 1 │ │ 2 │ + /// │ ├───┐ ┌───────────┐ ┌───────────┐ ┌─►│ │ + /// └────────┘ │ │ │ │ │ │ └─────────────┘ + /// └──►│ echo ├─────►│ dual echo ├─────┘ + /// │ 2 │ │ 1 │ + /// │ │ ┌──►│ │ + /// └───────────┘ │ └───────────┘ + /// SECONDARY START ──────────────────────────────────┘ + /// PROCESS + /// + /// + /// + /// + #region Experimental Tests not necessarily need to be ported + [Fact] + public async Task LongRunningProcessWith2BranchesAsync() + { + // Arrange + var processId = "myProcessId"; + var processStorage = new MockStorage(); + + Kernel kernel = new(); + ProcessBuilder processBuilder = new(nameof(LongRunningProcessWith2BranchesAsync)); + + var echo1 = processBuilder.AddStepFromType("echo1"); + + var delayedEcho = processBuilder.AddStepFromType(); + + var echo2 = processBuilder.AddStepFromType("echo2"); + var dualEcho1 = processBuilder.AddStepFromType("dualEcho1"); + + var dualEcho2 = processBuilder.AddStepFromType("dualEcho2"); + + processBuilder + .OnInputEvent(CommonProcesses.ProcessEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(echo1)); + + echo1 + .OnEvent(CommonSteps.EchoStep.OutputEvents.EchoMessage) + .SendEventTo(new ProcessFunctionTargetBuilder(delayedEcho)) + .SendEventTo(new ProcessFunctionTargetBuilder(echo2)); + + processBuilder.ListenFor().AllOf( + [ + new(CommonSteps.EchoStep.OutputEvents.EchoMessage, echo2), + new(CommonProcesses.ProcessEvents.OtherEvent, processBuilder) + ]).SendEventTo(new ProcessStepTargetBuilder(dualEcho1, inputMapping: (inputEvents) => + { + // Map the inputs to the last step. + return new() + { + { "message1", inputEvents[echo2.GetFullEventId(CommonSteps.EchoStep.OutputEvents.EchoMessage)] }, + { "message2", inputEvents[processBuilder.GetFullEventId(CommonProcesses.ProcessEvents.OtherEvent)] } + }; + })); + + processBuilder.ListenFor().AllOf( + [ + new(CommonSteps.DualEchoStep.OutputEvents.EchoMessage, dualEcho1), + new(CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho, delayedEcho) + ]).SendEventTo(new ProcessStepTargetBuilder(dualEcho2, inputMapping: (inputEvents) => + { + // Map the inputs to the last step. + return new() + { + { "message1", inputEvents[dualEcho1.GetFullEventId(CommonSteps.DualEchoStep.OutputEvents.EchoMessage)] }, + { "message2", inputEvents[delayedEcho.GetFullEventId(CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho)] } + }; + })); + + KernelProcess process = processBuilder.Build(); + + var testInput = "Hello, World!"; + + await using (var context = process.CreateContext(kernel, processId, storageConnector: processStorage)) + { + var task = context.StartWithEventKeepRunning(new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.StartProcess, + Data = testInput, + }, kernel); + + var runningProcessTask = Task.Run(() => task.Start()); + + // wait 3 seconds, then send event while process is still running + await Task.Delay(TimeSpan.FromSeconds(3)); + + await context.SendEventAsync(new KernelProcessEvent() + { + Id = CommonProcesses.ProcessEvents.OtherEvent, + Data = "Secondary input", + }); + + await context.StopAsync(); + } + } + + #region Test to validate KernelProcessUserState temporarily + // Temporarily plumbed localStep = new LocalStep(stepInfo, this._kernel, parentProcessId: this.Id, userStateStore: this._userStateStore) + // in LocalProcess.InitializeProcessAsync() + // Ideally this._userStateStore should be only plumbed to LocalDelegateStep only + + /// + /// Validates that the process state is persisted after modifying it from 2 steps in first run and from 1 in next run + /// + /// ┌───────┐ ┌───────┐ ┌───────┐ + /// │ │ │ │ │ │ + /// INPUT ──────►│ Int ├───────►│ Str ├─────►│ Int │ + /// INT │ Modif │ │ Modif │ │ Modif │ + /// │ │ ┌──►│ │ │ │ + /// └───────┘ │ └───────┘ └───────┘ + /// INPUT ────────────────────┘ + /// STR + /// ┌───────┐ + /// │ │ + /// INPUT ──────►│ Int │ + /// BOOL │ Modif │ + /// │ │ + /// └───────┘ + /// + /// + /// + [Fact] + public async Task ValidateProcessStatePersistedAfterModifyingFromStepAsync() + { + // Arrange + var processName = nameof(ValidateProcessStatePersistedAfterModifyingFromStepAsync); + var processId = "myProcessId"; + var processStorage = new MockStorage(); + var processStateEntryKey = $"{processId}.{processName}.ProcessDetails"; + + var kernel = new Kernel(); + + var inputIntEvent = "InputInt"; + var inputStringEvent = "InputString"; + var inputBoolEvent = "InputBool"; + + var testInput = new MyCustomClass() + { + Name = "Hello", + Value = 3, + Flag = true + }; + + var expectedOutput = new MyCustomClass() + { + Name = "Hello Hello Hello", + Value = 3, + Flag = true, + }; + + var processBuilder = new ProcessBuilder(processName); + + var intModifierStep = processBuilder.AddStepFromType("IntModifier"); + var stringModifierStep = processBuilder.AddStepFromType("StringModifier"); + var boolModifierStep = processBuilder.AddStepFromType("BoolModifier"); + + processBuilder + .OnInputEvent(inputBoolEvent) + .SendEventTo(new ProcessFunctionTargetBuilder(boolModifierStep, functionName: ProcessStateModifierStep.FunctionNames.SetFlag)); + + processBuilder + .OnInputEvent(inputIntEvent) + .SendEventTo(new ProcessFunctionTargetBuilder(intModifierStep, functionName: ProcessStateModifierStep.FunctionNames.IncreaseInt)); + + processBuilder.ListenFor().AllOf([ + new(inputStringEvent, processBuilder), + new(intModifierStep.GetFunctionResultEventId(ProcessStateModifierStep.FunctionNames.IncreaseInt), intModifierStep) + ]) + .SendEventTo(new ProcessStepTargetBuilder(stringModifierStep, functionName: ProcessStateModifierStep.FunctionNames.RepeatString, inputMapping: (inputEvents) => + { + return new() + { + { "text", inputEvents[processBuilder.GetFullEventId(inputStringEvent)] }, + { "repeatCount", inputEvents[intModifierStep.GetFullEventId(functionName: ProcessStateModifierStep.FunctionNames.IncreaseInt)] }, + }; + })); + + var process = processBuilder.Build(); + + // Act - 1 + await using LocalKernelProcessContext runningProcess = await process.StartAsync(kernel, new KernelProcessEvent() + { + Id = inputIntEvent, + Data = testInput.Value, + }, processId: processId, storageConnector: processStorage); + + // Assert - 1 + var expectedSharedVar1 = this.ValidateSpecificProcessStateVariables(processStorage, processStateEntryKey, MockProcessStateKeys.CustomObjectValue); + Assert.Equal(expectedOutput.Value, expectedSharedVar1.Value); + + // Act - 2 + await using LocalKernelProcessContext runningProcess2 = await process.StartAsync(kernel, new KernelProcessEvent() + { + Id = inputStringEvent, + Data = testInput.Name, + }, processId: processId, storageConnector: processStorage); + + // Assert - 2 + var expectedSharedVar2 = this.ValidateSpecificProcessStateVariables(processStorage, processStateEntryKey, MockProcessStateKeys.CustomObjectValue); + Assert.Equal(expectedOutput.Value, expectedSharedVar2.Value); + Assert.Equal(expectedOutput.Name, expectedSharedVar2.Name); + + // Act - 3 + await using LocalKernelProcessContext runningProcess3 = await process.StartAsync(kernel, new KernelProcessEvent() + { + Id = inputBoolEvent, + Data = testInput.Flag, + }, processId: processId, storageConnector: processStorage); + + // Assert - 3 + var expectedSharedVar3 = this.ValidateSpecificProcessStateVariables(processStorage, processStateEntryKey, MockProcessStateKeys.CustomObjectValue); + Assert.Equal(expectedOutput.Value, expectedSharedVar3.Value); + Assert.Equal(expectedOutput.Name, expectedSharedVar2.Name); + Assert.Equal(expectedOutput.Flag, expectedSharedVar3.Flag); + } + + private T ValidateSpecificProcessStateVariables(MockStorage storage, string processEntryKey, string processVariableName) where T : class + { + Assert.True(storage._dbMock.ContainsKey(processEntryKey)); + var processData = JsonSerializer.Deserialize(storage._dbMock[processEntryKey].Content); + Assert.NotNull(processData); + var processState = processData.ProcessState; + Assert.NotNull(processState?.SharedVariables); + Assert.True(processState?.SharedVariables.ContainsKey(MockProcessStateKeys.CustomObjectValue)); + var modifiedSharedVariableObj = processState?.SharedVariables[MockProcessStateKeys.CustomObjectValue]?.ToObject(); + Assert.IsType(modifiedSharedVariableObj); + return (T)modifiedSharedVariableObj; + } + + public static class MockProcessStateKeys + { + public static readonly string IntValue = nameof(IntValue); + public static readonly string StringValue = nameof(StringValue); + public static readonly string CustomObjectValue = nameof(CustomObjectValue); + } + + private sealed record MyCustomClass + { + public string Name { get; set; } = string.Empty; + public int Value { get; set; } = 0; + + public bool Flag { get; set; } = false; + } + + private sealed class ProcessStateModifierStep : KernelProcessStep + { + public static class FunctionNames + { + public const string IncreaseInt = nameof(IncreaseInt); + public const string RepeatString = nameof(RepeatString); + public const string SetFlag = nameof(SetFlag); + } + + [KernelFunction(FunctionNames.IncreaseInt)] + public async Task IncreaseIntAsync(KernelProcessStepContext context, int value) + { + var currentValue = await context.GetUserStateAsync(MockProcessStateKeys.CustomObjectValue).ConfigureAwait(false) ?? new(); + currentValue.Value += value; + + await context.SetUserStateAsync(MockProcessStateKeys.CustomObjectValue, currentValue).ConfigureAwait(false); + + return currentValue.Value; + } + + [KernelFunction(FunctionNames.RepeatString)] + public async Task IncreaseIntAsync(KernelProcessStepContext context, string text, int repeatCount = 2) + { + var currentValue = await context.GetUserStateAsync(MockProcessStateKeys.CustomObjectValue).ConfigureAwait(false) ?? new(); + currentValue.Name = string.Join(" ", Enumerable.Repeat(text, repeatCount)); + + await context.SetUserStateAsync(MockProcessStateKeys.CustomObjectValue, currentValue).ConfigureAwait(false); + + return currentValue.Name; + } + + [KernelFunction(FunctionNames.SetFlag)] + public async Task SetFlagAsync(KernelProcessStepContext context, bool updatedFlag) + { + var currentValue = await context.GetUserStateAsync(MockProcessStateKeys.CustomObjectValue).ConfigureAwait(false) ?? new(); + currentValue.Flag = updatedFlag; + + await context.SetUserStateAsync(MockProcessStateKeys.CustomObjectValue, currentValue).ConfigureAwait(false); + + return currentValue.Flag; + } + } + + #endregion + #endregion + /// /// A class that represents a step for testing. /// diff --git a/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProxyTests.cs b/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProxyTests.cs index 51ec8fbd739e..ee06ae87e0e4 100644 --- a/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProxyTests.cs +++ b/dotnet/src/Experimental/Process.UnitTests/Runtime.Local/LocalProxyTests.cs @@ -269,6 +269,6 @@ await process.StartAsync( Id = inputEvent, Data = input, }, - externalMessageChannel); + externalMessageChannel: externalMessageChannel); } } diff --git a/dotnet/src/Experimental/Process.Utilities.UnitTests/CloneTests.cs b/dotnet/src/Experimental/Process.Utilities.UnitTests/CloneTests.cs index fb0c4764b081..9ed3f4d1f31c 100644 --- a/dotnet/src/Experimental/Process.Utilities.UnitTests/CloneTests.cs +++ b/dotnet/src/Experimental/Process.Utilities.UnitTests/CloneTests.cs @@ -137,10 +137,44 @@ public void VerifyCloneMapStepTest() VerifyProcess(source, copy); } + /// + /// Verify that cloning a with a new run ID and edges works correctly. + /// + [Fact] + public void VerifyCloneWithIdAndEdgesTest() + { + // Arrange + string runningId = Guid.NewGuid().ToString(); + string stepName = nameof(VerifyCloneWithIdAndEdgesTest); + Dictionary> originalStepEdges = new() + { + { $"{stepName}.SomeOutputEvent1", CreateTestProcessEdges(1) }, + { $"{stepName}.{stepName}", CreateTestProcessEdges(3) }, + }; + KernelProcessStepInfo step = new(typeof(KernelProcessStep), new(stepName, "v1"), originalStepEdges); + + // Act + KernelProcessStepInfo copy = step.CloneWithIdAndEdges(runningId, NullLogger.Instance); + + // Assert + Assert.NotNull(copy); + Assert.Equal(stepName, copy.State.StepId); + Assert.Equal(runningId, copy.State.RunId); + foreach (var (expectedEdges, actualEdges) in step.Edges.Zip(copy.Edges)) + { + Assert.Contains(runningId, actualEdges.Key); + + var runningIdCountInEvent = actualEdges.Key.Split(runningId).Length - 1; + Assert.Equal(1, runningIdCountInEvent); + + Assert.Equivalent(expectedEdges.Value, actualEdges.Value); + } + } + private static void VerifyProcess(KernelProcess expected, KernelProcess actual) { - Assert.Equal(expected.State.Id, actual.State.Id); - Assert.Equal(expected.State.Name, actual.State.Name); + Assert.Equal(expected.State.RunId, actual.State.RunId); + Assert.Equal(expected.State.StepId, actual.State.StepId); Assert.Equal(expected.State.Version, actual.State.Version); Assert.Equal(expected.InnerStepType, actual.InnerStepType); Assert.Equivalent(expected.Edges, actual.Edges); @@ -163,12 +197,20 @@ private static Dictionary> CreateTestEdges() => { { "sourceId", - [ - new KernelProcessEdge("sourceId", new KernelProcessFunctionTarget("sourceId", "targetFunction", "targetParameter", "targetEventId")), - ] + CreateTestProcessEdges(1) } }; + private static List CreateTestProcessEdges(int count = 1) + { + var edges = new List(); + for (int i = 0; i < count; i++) + { + edges.Add(new KernelProcessEdge($"sourceId{i}", new KernelProcessFunctionTarget($"sourceId{i}", "targetFunction", "targetParameter", $"targetEventId{i}"))); + } + return edges; + } + private sealed record TestState { public Guid Value { get; set; } diff --git a/dotnet/src/Experimental/Process.Utilities.UnitTests/ObservableChannelTests.cs b/dotnet/src/Experimental/Process.Utilities.UnitTests/ObservableChannelTests.cs new file mode 100644 index 000000000000..8d788abaa46b --- /dev/null +++ b/dotnet/src/Experimental/Process.Utilities.UnitTests/ObservableChannelTests.cs @@ -0,0 +1,175 @@ +// Copyright (c) Microsoft. All rights reserved. +using System.Threading.Channels; +using System.Threading.Tasks; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Process.Internal; +using Xunit; + +namespace SemanticKernel.Process.Utilities.UnitTests; + +/// +/// Tests for . +/// +public class ObservableChannelTests +{ + private static readonly KernelProcessEvent s_testEvent1 = new() { Data = "someData1", Id = "myId1", Visibility = KernelProcessEventVisibility.Public }; + private static readonly KernelProcessEvent s_testEvent2 = new() { Data = "someData2", Id = "myId2", Visibility = KernelProcessEventVisibility.Public }; + private static readonly KernelProcessEvent s_testEvent3 = new() { Data = "someData3", Id = "myId3", Visibility = KernelProcessEventVisibility.Public }; + + /// + /// Tests that items added to the channel can be read and peeked correctly. + /// + /// + [Fact] + public async Task VerifyAfterAddingWithWriteAsyncItemsGetSnapshotAsync() + { + // Arrange + var observableChannel = new ObservableChannel(Channel.CreateUnbounded()); + + await observableChannel.WriteAsync(s_testEvent1); + await observableChannel.WriteAsync(s_testEvent2); + await observableChannel.WriteAsync(s_testEvent3); + + // Act + var snapshot = observableChannel.GetChannelSnapshot(); + observableChannel.TryPeak(out var peakChannelItem); + + // Assert + Assert.Equal(3, snapshot.Count); + Assert.Contains(snapshot, e => e.Id == s_testEvent1.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent2.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent3.Id); + Assert.NotNull(peakChannelItem); + Assert.Equal(s_testEvent1.Id, peakChannelItem?.Id); + } + + /// + /// Tests that items added to the channel can be read and peeked correctly using TryWriteAsync. + /// + /// + [Fact] + public void VerifyAfterAddingWithTryWriteAsyncItemsGetSnapshot() + { + // Arrange + var observableChannel = new ObservableChannel(Channel.CreateUnbounded()); + + observableChannel.TryWrite(s_testEvent1); + observableChannel.TryWrite(s_testEvent2); + observableChannel.TryWrite(s_testEvent3); + + // Act + var snapshot = observableChannel.GetChannelSnapshot(); + observableChannel.TryPeak(out var peakChannelItem); + + // Assert + Assert.Equal(3, snapshot.Count); + Assert.Contains(snapshot, e => e.Id == s_testEvent1.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent2.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent3.Id); + Assert.NotNull(peakChannelItem); + Assert.Equal(s_testEvent1.Id, peakChannelItem?.Id); + } + + /// + /// Tests that the channel returns an empty array when no items have been added. + /// + /// + [Fact] + public void VerifyReturnsEmptyArrayWhenNoItemsAdded() + { + // Arrange + var observableChannel = new ObservableChannel(Channel.CreateUnbounded()); + + // Act + var snapshot = observableChannel.GetChannelSnapshot(); + observableChannel.TryPeak(out var peakChannelItem); + + // Assert + Assert.Empty(snapshot); + Assert.Null(peakChannelItem); + } + + /// + /// Tests that the channel can be rehydrated from an initial state and returns the correct snapshot. + /// + /// + [Fact] + public void VerifyChannelRehydratedProperlyFromInitialState() + { + // Arrange + var initialState = new KernelProcessEvent[] + { + s_testEvent1, + s_testEvent2, + s_testEvent3, + }; + var observableChannel = new ObservableChannel(Channel.CreateUnbounded(), initialState: initialState); + + // Act + var snapshot = observableChannel.GetChannelSnapshot(); + observableChannel.TryPeak(out var peakChannelItem); + + // Assert + Assert.Equal(3, snapshot.Count); + Assert.Contains(snapshot, e => e.Id == s_testEvent1.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent2.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent3.Id); + Assert.NotNull(peakChannelItem); + Assert.Equal(s_testEvent1.Id, peakChannelItem?.Id); + } + + /// + /// Tests that the channel can be rehydrated from an initial state and reading an item after that returns the correct snapshot. + /// + /// + [Fact] + public void VerifyChannelRehydratedProperlyFromInitialStateAndReadingItemAfter() + { + // Arrange + var initialState = new KernelProcessEvent[] + { + s_testEvent1, + s_testEvent2, + s_testEvent3, + }; + var observableChannel = new ObservableChannel(Channel.CreateUnbounded(), initialState: initialState); + + // Act + observableChannel.TryRead(out _); // Read the first item + var snapshot = observableChannel.GetChannelSnapshot(); + observableChannel.TryPeak(out var peakChannelItem); + + // Assert + Assert.Equal(2, snapshot.Count); + Assert.DoesNotContain(snapshot, e => e.Id == s_testEvent1.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent2.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent3.Id); + Assert.NotNull(peakChannelItem); + Assert.Equal(s_testEvent2.Id, peakChannelItem?.Id); + } + + [Fact] + public void VerifyChannelRehydratedProperlyFromInitialStateAndAddingItemAfter() + { + // Arrange + var initialState = new KernelProcessEvent[] + { + s_testEvent1, + s_testEvent2, + }; + var observableChannel = new ObservableChannel(Channel.CreateUnbounded(), initialState: initialState); + + // Act + observableChannel.TryWrite(s_testEvent3); // Read the first item + var snapshot = observableChannel.GetChannelSnapshot(); + observableChannel.TryPeak(out var peakChannelItem); + + // Assert + Assert.Equal(3, snapshot.Count); + Assert.Contains(snapshot, e => e.Id == s_testEvent1.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent2.Id); + Assert.Contains(snapshot, e => e.Id == s_testEvent3.Id); + Assert.NotNull(peakChannelItem); + Assert.Equal(s_testEvent1.Id, peakChannelItem?.Id); + } +} diff --git a/dotnet/src/Experimental/Process.Utilities.UnitTests/Process.Utilities.UnitTests.csproj b/dotnet/src/Experimental/Process.Utilities.UnitTests/Process.Utilities.UnitTests.csproj index df58c070e53d..04e22c407179 100644 --- a/dotnet/src/Experimental/Process.Utilities.UnitTests/Process.Utilities.UnitTests.csproj +++ b/dotnet/src/Experimental/Process.Utilities.UnitTests/Process.Utilities.UnitTests.csproj @@ -39,4 +39,4 @@ - + \ No newline at end of file diff --git a/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStateMetadataFactory.cs b/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStateMetadataFactory.cs index 2c9be1a1c03e..2540732f76bd 100644 --- a/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStateMetadataFactory.cs +++ b/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStateMetadataFactory.cs @@ -15,15 +15,15 @@ public static KernelProcessStateMetadata KernelProcessToProcessStateMetadata(Ker { KernelProcessStateMetadata metadata = new() { - Name = kernelProcess.State.Name, - Id = kernelProcess.State.Id, + Name = kernelProcess.State.StepId, + Id = kernelProcess.State.RunId, VersionInfo = kernelProcess.State.Version, StepsState = [], }; foreach (KernelProcessStepInfo step in kernelProcess.Steps) { - metadata.StepsState.Add(step.State.Name, step.ToProcessStateMetadata()); + metadata.StepsState.Add(step.State.StepId, step.ToProcessStateMetadata()); } return metadata; @@ -52,8 +52,8 @@ private static KernelProcessMapStateMetadata KernelProcessMapToProcessStateMetad return new() { - Name = stepMap.State.Name, - Id = stepMap.State.Id, + Name = stepMap.State.StepId, + Id = stepMap.State.RunId, VersionInfo = stepMap.State.Version, OperationState = ToProcessStateMetadata(stepMap.Operation), }; @@ -63,8 +63,8 @@ private static KernelProcessProxyStateMetadata KernelProcessProxyToProcessStateM { return new() { - Name = stepProxy.State.Name, - Id = stepProxy.State.Id, + Name = stepProxy.State.StepId, + Id = stepProxy.State.RunId, VersionInfo = stepProxy.State.Version, PublishTopics = stepProxy.ProxyMetadata?.PublishTopics ?? [], EventMetadata = stepProxy.ProxyMetadata?.EventMetadata ?? [], @@ -79,8 +79,8 @@ private static KernelProcessStepStateMetadata StepInfoToProcessStateMetadata(Ker { KernelProcessStepStateMetadata metadata = new() { - Name = stepInfo.State.Name, - Id = stepInfo.State.Id, + Name = stepInfo.State.StepId, + Id = stepInfo.State.RunId, VersionInfo = stepInfo.State.Version }; diff --git a/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStepEdgesExtension.cs b/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStepEdgesExtension.cs new file mode 100644 index 000000000000..38c9e4c1a202 --- /dev/null +++ b/dotnet/src/InternalUtilities/process/Abstractions/KernelProcessStepEdgesExtension.cs @@ -0,0 +1,38 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; + +namespace Microsoft.SemanticKernel.Process.Internal; + +internal static class KernelProcessStepEdgesExtensions +{ + public static Dictionary> PackStepEdgesValues(this Dictionary?> functionsParameters) + { + Dictionary> stepFunctionParamsEventData = []; + foreach (var function in functionsParameters) + { + var functionName = function.Key; + stepFunctionParamsEventData[functionName] = []; + foreach (var parameterData in function.Value ?? []) + { + var parameterName = parameterData.Key; + if (parameterData.Value is null) + { + stepFunctionParamsEventData[functionName][parameterName] = null; + continue; + } + + // Avoid storing parameters that are automatically injected by the step + // Must match cases in StepExtensions.FindInputChannels + if (parameterData.Value is Kernel or KernelProcessStepContext or KernelProcessStepExternalContext) + { + continue; + } + + stepFunctionParamsEventData[functionName][parameterName] = KernelProcessEventData.FromObject(parameterData.Value); + } + } + + return stepFunctionParamsEventData; + } +} diff --git a/dotnet/src/InternalUtilities/process/Abstractions/MapExtensions.cs b/dotnet/src/InternalUtilities/process/Abstractions/MapExtensions.cs index b42be3c87a9e..30bdb073e8cb 100644 --- a/dotnet/src/InternalUtilities/process/Abstractions/MapExtensions.cs +++ b/dotnet/src/InternalUtilities/process/Abstractions/MapExtensions.cs @@ -8,7 +8,7 @@ internal static class MapExtensions { public static KernelProcessMap CloneMap(this KernelProcessMap map, ILogger logger) { - KernelProcessMapState newState = new(map.State.Name, map.State.Version, map.State.Id!); + KernelProcessMapState newState = new(map.State.StepId, map.State.Version, map.State.RunId!); KernelProcessMap copy = new( diff --git a/dotnet/src/InternalUtilities/process/Abstractions/ProcessExtensions.cs b/dotnet/src/InternalUtilities/process/Abstractions/ProcessExtensions.cs index 84143151da95..cdf958c6c431 100644 --- a/dotnet/src/InternalUtilities/process/Abstractions/ProcessExtensions.cs +++ b/dotnet/src/InternalUtilities/process/Abstractions/ProcessExtensions.cs @@ -11,7 +11,7 @@ public static KernelProcess CloneProcess(this KernelProcess process, ILogger log { KernelProcess copy = new( - new KernelProcessState(process.State.Name, process.State.Version, process.State.Id), + new KernelProcessState(process.State.StepId, process.State.Version, process.State.RunId), process.Steps.Select(s => s.Clone(logger)).ToArray(), process.Edges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToList())); diff --git a/dotnet/src/InternalUtilities/process/Abstractions/StepExtensions.cs b/dotnet/src/InternalUtilities/process/Abstractions/StepExtensions.cs index ecada9c6abc9..018130b05fd5 100644 --- a/dotnet/src/InternalUtilities/process/Abstractions/StepExtensions.cs +++ b/dotnet/src/InternalUtilities/process/Abstractions/StepExtensions.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Text.RegularExpressions; using Microsoft.Extensions.Logging; using Microsoft.SemanticKernel.Agents; @@ -38,10 +39,10 @@ public static KernelProcessStepInfo Clone(this KernelProcessStepInfo step, ILogg // Exposed for testing public static KernelProcessStepState Clone(this KernelProcessStepState sourceState, Type stateType, Type? userStateType, ILogger logger) { - KernelProcessStepState? newState = (KernelProcessStepState?)Activator.CreateInstance(stateType, sourceState.Name, sourceState.Version, sourceState.Id); + KernelProcessStepState? newState = (KernelProcessStepState?)Activator.CreateInstance(stateType, sourceState.StepId, sourceState.Version, sourceState.RunId); if (newState == null) { - throw new KernelException($"Failed to instantiate state: {stateType.Name} [{sourceState.Id}].").Log(logger); + throw new KernelException($"Failed to instantiate state: {stateType.Name} [{sourceState.RunId}].").Log(logger); } if (userStateType != null) @@ -104,6 +105,7 @@ public static void InitializeUserState(this KernelProcessStepState stateObject, /// An instance of . /// An instance of /// An instance of + /// /// /// public static Dictionary?> FindInputChannels( @@ -111,7 +113,8 @@ public static void InitializeUserState(this KernelProcessStepState stateObject, Dictionary functions, ILogger? logger, IExternalKernelProcessMessageChannel? externalMessageChannel = null, - AgentDefinition? agentDefinition = null) + AgentDefinition? agentDefinition = null, + IKernelProcessUserStateStore? stateStore = null) { if (functions is null) { @@ -134,7 +137,7 @@ public static void InitializeUserState(this KernelProcessStepState stateObject, // and are instantiated here. if (param.ParameterType == typeof(KernelProcessStepContext)) { - inputs[kvp.Key]![param.Name] = new KernelProcessStepContext(channel); + inputs[kvp.Key]![param.Name] = new KernelProcessStepContext(channel, stateStore); } else if (param.ParameterType == typeof(KernelProcessStepExternalContext)) { @@ -153,4 +156,47 @@ public static void InitializeUserState(this KernelProcessStepState stateObject, return inputs; } + + private static IReadOnlyDictionary> ReplaceEdgeSourceNames(IReadOnlyDictionary> edges, string originalSourceName, string newSourceName) + { + if (edges.Count == 0) + { + return edges; + } + + var updatedEdges = new Dictionary>(); + + foreach (var kvp in edges) + { + // Ensuring only replacing the first occurrence of the original source name in case it is also used in event name or other parts of the event name. + var regex = new Regex($"^{originalSourceName}"); + var newKey = regex.Replace(kvp.Key, newSourceName, 1); + + updatedEdges[newKey] = kvp.Value; + } + + return updatedEdges; + } + + /// + /// Creates a new instance of the class with a new step ID and updated edges. + /// + /// instance of + /// id to be assigned to the updated step info + /// instance of + /// + public static KernelProcessStepInfo CloneWithIdAndEdges(this KernelProcessStepInfo step, string stepId, ILogger logger) + { + if (string.IsNullOrWhiteSpace(stepId)) + { + throw new KernelException("Internal Error: The step needs a non-empty id").Log(logger); + } + + return step with { State = step.State with { RunId = stepId }, Edges = ReplaceEdgeSourceNames(step.Edges, step.State.StepId, stepId) }; + } + + public static bool IsDefault(this KernelProcessEdgeCondition condition) + { + return condition.DeclarativeDefinition?.Equals(ProcessConstants.Declarative.DefaultCondition, StringComparison.OrdinalIgnoreCase) ?? false; + } } diff --git a/dotnet/src/InternalUtilities/process/LocalStorageComponents.props b/dotnet/src/InternalUtilities/process/LocalStorageComponents.props new file mode 100644 index 000000000000..69f1bf256ada --- /dev/null +++ b/dotnet/src/InternalUtilities/process/LocalStorageComponents.props @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/dotnet/src/InternalUtilities/process/Runtime/MapExtensions.cs b/dotnet/src/InternalUtilities/process/Runtime/MapExtensions.cs index 45118c93840f..a6bbd61e30f1 100644 --- a/dotnet/src/InternalUtilities/process/Runtime/MapExtensions.cs +++ b/dotnet/src/InternalUtilities/process/Runtime/MapExtensions.cs @@ -37,9 +37,9 @@ public static (IEnumerable, KernelProcess, string) Initialize(this KernelProcess string proxyId = Guid.NewGuid().ToString("N"); mapOperation = new KernelProcess( - new KernelProcessState($"Map{map.Operation.State.Name}", map.Operation.State.Version, proxyId), + new KernelProcessState($"Map{map.Operation.State.StepId}", map.Operation.State.Version, proxyId), [map.Operation], - new() { { ProcessConstants.MapEventId, [new KernelProcessEdge(proxyId, new KernelProcessFunctionTarget(map.Operation.State.Id!, message.FunctionName, parameterName))] } }); + new() { { ProcessConstants.MapEventId, [new KernelProcessEdge(proxyId, new KernelProcessFunctionTarget(map.Operation.State.RunId!, message.FunctionName, parameterName))] } }); } return (inputValues, mapOperation, startEventId); @@ -110,7 +110,7 @@ private static string DefineOperationEventId(KernelProcess mapOperation, Process // Fails when zero or multiple candidate edges exist. No reason a map-operation should be irrational. return mapOperation.Edges.SingleOrDefault(kvp => kvp.Value.Any(e => (e.OutputTarget as KernelProcessFunctionTarget)!.FunctionName == message.FunctionName)).Key ?? - throw new InvalidOperationException($"The map operation does not have an input edge that matches the message destination: {mapOperation.State.Name}/{mapOperation.State.Id}."); + throw new InvalidOperationException($"The map operation does not have an input edge that matches the message destination: {mapOperation.State.StepId}/{mapOperation.State.RunId}."); } private static bool IsEqual(IEnumerable targetData, object? possibleValue) @@ -157,4 +157,24 @@ private static bool IsEqual(IEnumerable targetData, object? possibleValue) return false; } + + public static T GetStepInfo(this IReadOnlyDictionary processes, string processId, string stepId) where T : KernelProcessStepInfo + { + Verify.NotNull(processes, nameof(processes)); + Verify.NotNullOrWhiteSpace(processId, nameof(processId)); + Verify.NotNullOrWhiteSpace(stepId, nameof(stepId)); + + if (!processes.TryGetValue(processId, out var registeredProcess) || registeredProcess is null) + { + throw new InvalidOperationException("No process registered with the specified key"); + } + + var targetStep = registeredProcess.Steps.Where(s => s.State.StepId == stepId).FirstOrDefault(); + if (targetStep is null || targetStep is not T typedTarget) + { + throw new InvalidOperationException("The specific step could not be found in the specified process."); + } + + return typedTarget; + } } diff --git a/dotnet/src/InternalUtilities/process/Runtime/ObservableChannel.cs b/dotnet/src/InternalUtilities/process/Runtime/ObservableChannel.cs new file mode 100644 index 000000000000..483a7f8880e2 --- /dev/null +++ b/dotnet/src/InternalUtilities/process/Runtime/ObservableChannel.cs @@ -0,0 +1,106 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Channels; +using System.Threading.Tasks; + +namespace Microsoft.SemanticKernel.Process.Internal; + +// Workaround to have access to all channel items since Channel only allows reading the latest item. +internal class ObservableChannel +{ + private readonly Channel _channel; + private readonly ConcurrentQueue _snapshot = new(); + + public ObservableChannel(Channel channel, IEnumerable? initialState = null) + { + this._channel = channel ?? throw new ArgumentNullException(nameof(channel)); + if (initialState != null) + { + foreach (var item in initialState) + { + this._snapshot.Enqueue(item); + this._channel.Writer.TryWrite(item); + } + } + } + + /// + /// Returns a collection of the items in the channel + /// + /// An array containing the items + public List GetChannelSnapshot() + { + return this._snapshot.ToList(); + } + + #region Read related methods + + /// + public bool TryRead(out T? item) + { + bool successRead = this._channel.Reader.TryRead(out item); + if (successRead) + { + this._snapshot.TryDequeue(out _); + } + + return successRead; + } + + /// + public bool TryPeak(out T? item) + { + bool peekSuccess = this._channel.Reader.TryPeek(out item); + return peekSuccess; + } + + public async ValueTask WaitToReadAsync(CancellationToken cancellationToken = default) + { + try + { + return await this._channel.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false); + } + catch (Exception) + { + throw; + } + } + #endregion + #region Write related methods + /// + public async ValueTask WriteAsync(T item, CancellationToken cancellationToken = default) + { + try + { + await this._channel.Writer.WriteAsync(item, cancellationToken).ConfigureAwait(false); + this._snapshot.Enqueue(item); + } + catch (Exception) + { + throw; + } + } + + /// + public bool TryWrite(T item) + { + bool successWrite = this._channel.Writer.TryWrite(item); + if (successWrite) + { + this._snapshot.Enqueue(item); + } + + return successWrite; + } + + public void Complete() + { + this._channel.Writer.Complete(); + } + #endregion +} diff --git a/dotnet/src/InternalUtilities/process/TestsShared/Processes/CommonProcesses.cs b/dotnet/src/InternalUtilities/process/TestsShared/Processes/CommonProcesses.cs new file mode 100644 index 000000000000..8fe0477ba1ef --- /dev/null +++ b/dotnet/src/InternalUtilities/process/TestsShared/Processes/CommonProcesses.cs @@ -0,0 +1,336 @@ +// Copyright (c) Microsoft. All rights reserved. +using System.Collections.Generic; +using Microsoft.SemanticKernel; + +namespace SemanticKernel.Process.TestsShared.Steps; + +#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member + +/// +/// Collection of common steps used by UnitTests and IntegrationUnitTests +/// +public static class CommonProcesses +{ + public static class ProcessEvents + { + /// + /// Start Process Event + /// + public const string StartProcess = nameof(StartProcess); + public const string OtherEvent = nameof(OtherEvent); + } + + public static class ProcessKeys + { + public const string CounterProcess = nameof(CounterProcess); + public const string CounterWithEvenNumberDetectionProcess = nameof(CounterWithEvenNumberDetectionProcess); + public const string NestedCounterWithEvenDetectionAndMergeProcess = nameof(NestedCounterWithEvenDetectionAndMergeProcess); + public const string InternalNestedCounterWithEvenDetectionAndMergeProcess = nameof(InternalNestedCounterWithEvenDetectionAndMergeProcess); + public const string DelayedMergeProcess = nameof(DelayedMergeProcess); + public const string SimpleMergeProcess = nameof(SimpleMergeProcess); + } + + public static KernelProcess GetCounterProcess(string processName = ProcessKeys.CounterProcess) + { + ProcessBuilder process = new(processName); + + var counterStep = process.AddStepFromType(id: "counterStep"); + var echoStep = process.AddStepFromType(id: nameof(CommonSteps.EchoStep)); + + process + .OnInputEvent(ProcessEvents.StartProcess) + .SendEventTo(new(counterStep)); + + counterStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep)); + + return process.Build(); + } + + public static ProcessBuilder GetCounterWithEvenDetectionProcess(string processName = ProcessKeys.CounterWithEvenNumberDetectionProcess) + { + ProcessBuilder process = new(processName); + + var counterStep = process.AddStepFromType(id: "counterStep"); + var evenNumberStep = process.AddStepFromType(id: nameof(CommonSteps.EvenNumberDetectorStep)); + + process + .OnInputEvent(ProcessEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(counterStep)); + + counterStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(evenNumberStep)); + + return process; + } + + /// + /// + /// ┌───────┐ + /// │ │ + /// ┌───────────────────────────────────────────────────────────────────────►│ │ + /// │ │ │ + /// │ EvenNumber Event │ │ ┌───────────┐ + /// │ ┌─────────────────────────────────────────────────►│ merge ├──►│ finalEcho │ + /// │ │ │ │ └───────────┘ + /// │ │ ┌─────────────────────────────────────┐ │ │ + /// │ │ │ innerCounterProcess │ ┌──►│ │ + /// Start ┌───────────┐ │ ┌──────────────┐ │ │ ┌───────────┐ ┌──────────────┐ │ │ │ │ + /// Process ────►│ outer ├─┴─►│ outer ├───┴──►│ │ counter ├───►│ evenDetector ├──┼────┘ └───────┘ + /// Event │ counter │ │ evenDetector │ │ └───────────┘ └──────────────┘ │ EvenNumber + /// └───────────┘ └──────────────┘ └─────────────────────────────────────┘ Event + /// + /// + /// + /// + public static ProcessBuilder GetNestedCounterWithEvenDetectionAndMergeProcess(string processName = ProcessKeys.NestedCounterWithEvenDetectionAndMergeProcess) + { + ProcessBuilder process = new(processName); + + var outerCounterStep = process.AddStepFromType(id: "outerCounterStep"); + var outerEvenNumberStep = process.AddStepFromType(id: $"outer{nameof(CommonSteps.EvenNumberDetectorStep)}"); + var innerCounterProcess = process.AddStepFromProcess(GetCounterWithEvenDetectionProcess("innerCounterProcess")); + var mergeStep = process.AddStepFromType(id: nameof(CommonSteps.MergeStringsStep)); + var finalEchoStep = process.AddStepFromType(id: nameof(CommonSteps.EchoStep)); + + process + .OnInputEvent(ProcessEvents.StartProcess) + .SendEventTo(new ProcessFunctionTargetBuilder(outerCounterStep)); + + outerCounterStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(outerEvenNumberStep)); + + outerEvenNumberStep + .OnEvent(CommonSteps.EvenNumberDetectorStep.OutputEvents.EvenNumber) + .SendEventTo(innerCounterProcess.WhereInputEventIs(ProcessEvents.StartProcess)); + + // merging inputs + process + .ListenFor() + .AllOf([ + new(messageType: outerCounterStep.GetFunctionResultEventId(), outerCounterStep), + new(messageType: CommonSteps.EvenNumberDetectorStep.OutputEvents.EvenNumber, outerEvenNumberStep), + new(messageType: CommonSteps.EvenNumberDetectorStep.OutputEvents.EvenNumber, innerCounterProcess), + ]) + .SendEventTo(new ProcessStepTargetBuilder(mergeStep, inputMapping: (inputEvents) => + { + return new() + { + { "str1", inputEvents[outerCounterStep.GetFullEventId()] }, + { "str2", inputEvents[outerEvenNumberStep.GetFullEventId(CommonSteps.EvenNumberDetectorStep.OutputEvents.EvenNumber)] }, + { "str3", inputEvents[innerCounterProcess.GetFullEventId(CommonSteps.EvenNumberDetectorStep.OutputEvents.EvenNumber)] }, + }; + })); + + mergeStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(finalEchoStep)); + + return process; + } + + /// + /// Process that merges string from process onInput and nested AllOf triggered events from a nested process. + /// + /// ┌───────┐ + /// │ │ + /// ┌───────────────────────────────►│ │ + /// │ │ │ + /// │ │ │ ┌───────────┐ + /// │ ┌──►│ merge ├──►│ finalEcho │ + /// │ │ │ │ └───────────┘ + /// │ │ │ │ + /// │ ┌───────────────┐ ├──►│ │ + /// Start │ │ Nested │ │ │ │ + /// Process ───┴─►│ Counter ├─────────┘ └───────┘ + /// Event │ Process │ Echo + /// └───────────────┘ Event + /// + /// + /// + /// + public static KernelProcess GetInternalNestedCounterWithEvenDetectionAndMergeProcess(string processName = ProcessKeys.InternalNestedCounterWithEvenDetectionAndMergeProcess) + { + ProcessBuilder process = new(processName); + + var internalNestedCounterProcess = process.AddStepFromProcess(GetNestedCounterWithEvenDetectionAndMergeProcess("internalNestedCounterProcess")); + var mergeStep = process.AddStepFromType(id: nameof(CommonSteps.MergeStringsStep)); + var finalEchoStep = process.AddStepFromType(id: nameof(CommonSteps.EchoStep)); + + process + .OnInputEvent(ProcessEvents.StartProcess) + .SendEventTo(internalNestedCounterProcess.WhereInputEventIs(ProcessEvents.StartProcess)); + + // merging inputs + process.ListenFor() + .AllOf([ + new(messageType: ProcessEvents.StartProcess, process), + new(messageType: CommonSteps.EchoStep.OutputEvents.EchoMessage, internalNestedCounterProcess), + ]) + .SendEventTo(new ProcessStepTargetBuilder(mergeStep, inputMapping: (inputEvents) => + { + return new() + { + { "str1", inputEvents[process.GetFullEventId(ProcessEvents.StartProcess)] }, + { "str2", inputEvents[internalNestedCounterProcess.GetFullEventId(CommonSteps.EchoStep.OutputEvents.EchoMessage)] }, + { "str3", inputEvents[internalNestedCounterProcess.GetFullEventId(CommonSteps.EchoStep.OutputEvents.EchoMessage)] }, + }; + })); + + mergeStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(finalEchoStep)); + + return process.Build(); + } + + /// + /// Process that merges string from process onInput events when they are all available. + /// Helps test make use of ListenFor() and AllOf() methods with events from process. + /// + /// Other ───┐ ┌───────┐ + /// │ │ │ + /// └──►│ │ + /// │ │ + /// │ │ ┌───────────┐ + /// ┌────────►│ merge ├───►│ finalEcho │ + /// │ │ │ └───────────┘ + /// Start │ │ + /// Process ┌──►│ │ + /// │ │ │ │ + /// └─────┘ └───────┘ + /// + /// + /// + /// + public static KernelProcess GetSimpleMergeProcess(string processName = ProcessKeys.SimpleMergeProcess) + { + ProcessBuilder process = new(processName); + + var mergeStep = process.AddStepFromType(id: nameof(CommonSteps.MergeStringsStep)); + + var finalEchoStep = process.AddStepFromType(id: nameof(CommonSteps.EchoStep)); + + // merging inputs + process + .ListenFor() + .AllOf([ + new(messageType: ProcessEvents.StartProcess, process), + new(messageType: ProcessEvents.StartProcess, process), + new(messageType: ProcessEvents.OtherEvent, process), + ]) + .SendEventTo(new ProcessStepTargetBuilder(mergeStep, inputMapping: (inputEvents) => + { + return new() + { + { "str1", inputEvents[process.GetFullEventId(ProcessEvents.StartProcess)] }, + { "str2", inputEvents[process.GetFullEventId(ProcessEvents.StartProcess)] }, + { "str3", inputEvents[process.GetFullEventId(ProcessEvents.OtherEvent)] }, + }; + })); + + mergeStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(finalEchoStep)); + + return process.Build(); + } + + /// + /// Process that delays the merge of three strings until all three are available. + /// Helps test make use of ListenFor() and AllOf() methods with events from steps. + /// + /// ┌────────┐ + /// Other ─►│ echo1 ├───────────────────────────────┐ ┌───────┐ + /// └────────┘ │ │ │ + /// └──►│ │ + /// │ │ + /// ┌────────┐ ┌────────┐ │ │ ┌───────────┐ + /// ┌──► │ echo21 ├────►│ echo22 ├───────────────────►│ merge ├───►│ finalEcho │ + /// │ └────────┘ └────────┘ │ │ └───────────┘ + /// Start │ │ + /// Process ┌──►│ │ + /// │ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │ + /// └──► │ echo31 ├────►│ echo32 ├───►│ echo33 ├──┘ └───────┘ + /// └────────┘ └────────┘ └────────┘ + /// + /// + /// + /// + public static KernelProcess GetDelayedMergeProcess(string processName = ProcessKeys.DelayedMergeProcess) + { + ProcessBuilder process = new(processName); + + var echoStep1 = process.AddStepFromType(id: $"{nameof(CommonSteps.DelayedEchoStep)}1"); + var echoStep21 = process.AddStepFromType(id: $"{nameof(CommonSteps.DelayedEchoStep)}21"); + var echoStep22 = process.AddStepFromType(id: $"{nameof(CommonSteps.DelayedEchoStep)}22"); + var echoStep31 = process.AddStepFromType(id: $"{nameof(CommonSteps.DelayedEchoStep)}31"); + var echoStep32 = process.AddStepFromType(id: $"{nameof(CommonSteps.DelayedEchoStep)}32"); + var echoStep33 = process.AddStepFromType(id: $"{nameof(CommonSteps.DelayedEchoStep)}33"); + + var mergeStep = process.AddStepFromType(id: nameof(CommonSteps.MergeStringsStep)); + + var finalEchoStep = process.AddStepFromType(id: nameof(CommonSteps.EchoStep)); + + process + .OnInputEvent(ProcessEvents.StartProcess) + //.SendEventTo(new(echoStep1)) + .SendEventTo(new(echoStep21)) + .SendEventTo(new(echoStep31)); + + process + .OnInputEvent(ProcessEvents.OtherEvent) + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep1)); + + echoStep21 + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep22)); + + echoStep31 + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep32)); + + echoStep32 + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(echoStep33)); + + // merging inputs + process + .ListenFor() + .AllOf([ + new(messageType: CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho, echoStep1), + new(messageType: CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho, echoStep22), + new(messageType: CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho, echoStep33), + ]) + .SendEventTo(new ProcessStepTargetBuilder(mergeStep, inputMapping: (inputEvents) => + { + return new() + { + { "str1", inputEvents[echoStep1.GetFullEventId(CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho)] }, + { "str2", inputEvents[echoStep22.GetFullEventId(CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho)] }, + { "str3", inputEvents[echoStep33.GetFullEventId(CommonSteps.DelayedEchoStep.OutputEvents.DelayedEcho)] }, + }; + })); + + mergeStep + .OnFunctionResult() + .SendEventTo(new ProcessFunctionTargetBuilder(finalEchoStep)); + + return process.Build(); + } + + public static IReadOnlyDictionary GetCommonProcessesKeyedDictionary() + { + return new Dictionary() { + { ProcessKeys.CounterProcess, GetCounterProcess() }, + { ProcessKeys.CounterWithEvenNumberDetectionProcess, GetCounterWithEvenDetectionProcess().Build() }, + { ProcessKeys.NestedCounterWithEvenDetectionAndMergeProcess, GetNestedCounterWithEvenDetectionAndMergeProcess().Build() }, + { ProcessKeys.InternalNestedCounterWithEvenDetectionAndMergeProcess, GetInternalNestedCounterWithEvenDetectionAndMergeProcess() }, + { ProcessKeys.DelayedMergeProcess, GetDelayedMergeProcess() }, + { ProcessKeys.SimpleMergeProcess, GetSimpleMergeProcess() }, + }; + } +} diff --git a/dotnet/src/InternalUtilities/process/TestsShared/Services/CounterService.cs b/dotnet/src/InternalUtilities/process/TestsShared/Services/CounterService.cs index a393de8f6169..939ce0b7328a 100644 --- a/dotnet/src/InternalUtilities/process/TestsShared/Services/CounterService.cs +++ b/dotnet/src/InternalUtilities/process/TestsShared/Services/CounterService.cs @@ -17,4 +17,9 @@ public int IncreaseCount() Interlocked.Increment(ref this._counter); return this._counter; } + + public void SetCount(int count) + { + this._counter = count; + } } diff --git a/dotnet/src/InternalUtilities/process/TestsShared/Services/ICounterService.cs b/dotnet/src/InternalUtilities/process/TestsShared/Services/ICounterService.cs index caf6063fdea1..e0e4eddd0cff 100644 --- a/dotnet/src/InternalUtilities/process/TestsShared/Services/ICounterService.cs +++ b/dotnet/src/InternalUtilities/process/TestsShared/Services/ICounterService.cs @@ -17,4 +17,11 @@ public interface ICounterService /// /// int GetCount(); + + /// + /// Set counter to specific value + /// + /// + /// + void SetCount(int count); } diff --git a/dotnet/src/InternalUtilities/process/TestsShared/Services/Storage/JsonFileStorage.cs b/dotnet/src/InternalUtilities/process/TestsShared/Services/Storage/JsonFileStorage.cs new file mode 100644 index 000000000000..f9a36458cc0f --- /dev/null +++ b/dotnet/src/InternalUtilities/process/TestsShared/Services/Storage/JsonFileStorage.cs @@ -0,0 +1,75 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.IO; +using System.Text.Json; +using System.Threading.Tasks; +using Microsoft.SemanticKernel; + +namespace SemanticKernel.Process.TestsShared.Services.Storage; + +internal sealed class JsonFileStorage : IProcessStorageConnector +{ + private readonly string _storageDirectory; + + private readonly JsonSerializerOptions _jsonSerializerOptions = new() + { + WriteIndented = true, + }; + + public JsonFileStorage(string storageDirectory) + { + this._storageDirectory = storageDirectory; + Directory.CreateDirectory(this._storageDirectory); + } + + public async ValueTask OpenConnectionAsync() + { + // For file-based storage, there's no real "connection" to open. + // This method might be used to validate if the storage directory is accessible. + await Task.CompletedTask; + } + + public async ValueTask CloseConnectionAsync() + { + // For file-based storage, there's no real "connection" to close. + await Task.CompletedTask; + } + + private string GetFilePath(string id) + { + return Path.Combine(this._storageDirectory, $"{id}.json"); + } + + public async Task GetEntryAsync(string id) where TEntry : class + { + string filePath = this.GetFilePath(id); + if (!File.Exists(filePath)) + { + return null; + } + + string jsonData = await File.ReadAllTextAsync(filePath); + return JsonSerializer.Deserialize(jsonData); + } + + public async Task SaveEntryAsync(string id, string type, TEntry entry) where TEntry : class + { + string filePath = this.GetFilePath(id); + string jsonData = JsonSerializer.Serialize(entry, this._jsonSerializerOptions); + + await File.WriteAllTextAsync(filePath, jsonData); + return true; + } + + public Task DeleteEntryAsync(string id) + { + string filePath = this.GetFilePath(id); + if (File.Exists(filePath)) + { + File.Delete(filePath); + return Task.FromResult(true); + } + + return Task.FromResult(false); + } +} diff --git a/dotnet/src/InternalUtilities/process/TestsShared/Services/Storage/MockStorage.cs b/dotnet/src/InternalUtilities/process/TestsShared/Services/Storage/MockStorage.cs new file mode 100644 index 000000000000..bea9d27b6a8e --- /dev/null +++ b/dotnet/src/InternalUtilities/process/TestsShared/Services/Storage/MockStorage.cs @@ -0,0 +1,75 @@ +// Copyright (c) Microsoft. All rights reserved. +#pragma warning disable IDE0005 // Using directive is unnecessary +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Threading.Tasks; +using Microsoft.SemanticKernel; +#pragma warning restore IDE0005 // Using directive is unnecessary + +namespace SemanticKernel.Process.TestsShared.Services.Storage; + +internal sealed class MockStorage : IProcessStorageConnector +{ + internal readonly Dictionary _dbMock = []; + + public bool ConnectionOpened { get; private set; } = false; + public bool ConnectionClosed { get; private set; } = false; + + public ValueTask OpenConnectionAsync() + { + Console.WriteLine("Mock opening connection"); + this.ConnectionOpened = true; + return ValueTask.CompletedTask; + } + public ValueTask CloseConnectionAsync() + { + Console.WriteLine("Mock closing connection"); + this.ConnectionClosed = true; + return ValueTask.CompletedTask; + } + + public Task DeleteEntryAsync(string id) + { + throw new System.NotImplementedException(); + } + + public Task GetEntryAsync(string id) where TEntry : class + { + if (this._dbMock.TryGetValue(id, out var entry) && entry != null) + { + var deserializedEntry = JsonSerializer.Deserialize(entry.Content); + return Task.FromResult(deserializedEntry); + } + + return Task.FromResult(null); + } + + public Task SaveEntryAsync(string id, string type, TEntry entry) where TEntry : class + { + this._dbMock[id] = new() { Id = id, Type = type, Content = JsonSerializer.Serialize(entry) }; + + return Task.FromResult(true); + } +} + +/// +/// Mock storage entry used for testing purposes. +/// +public record MockStorageEntry +{ + /// + /// Unique identifier for the entry. + /// + public string Id { get; set; } = string.Empty; + + /// + /// Type of the entry. + /// + public string Type { get; set; } = string.Empty; + + /// + /// Serialized content of the entry. + /// + public string Content { get; set; } = string.Empty; +} diff --git a/dotnet/src/InternalUtilities/process/TestsShared/Steps/CommonSteps.cs b/dotnet/src/InternalUtilities/process/TestsShared/Steps/CommonSteps.cs index 5cf2fbcfd8e1..692c404b3917 100644 --- a/dotnet/src/InternalUtilities/process/TestsShared/Steps/CommonSteps.cs +++ b/dotnet/src/InternalUtilities/process/TestsShared/Steps/CommonSteps.cs @@ -1,5 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Threading; using System.Threading.Tasks; using Microsoft.SemanticKernel; using SemanticKernel.Process.TestsShared.Services; @@ -16,25 +17,65 @@ public static class CommonSteps /// /// The step that counts how many times it has been invoked. /// - public sealed class CountStep : KernelProcessStep + public sealed class CountStep : KernelProcessStep { public const string CountFunction = nameof(Count); private readonly ICounterService _counter; + + private CounterState? _state; public CountStep(ICounterService counterService) { this._counter = counterService; } + public override ValueTask ActivateAsync(KernelProcessStepState state) + { + this._state = state.State ?? new(); + this._counter.SetCount(this._state.Count); + Console.WriteLine($"Activating counter with value {this._state.Count}"); + return base.ActivateAsync(state); + } + [KernelFunction] public string Count() { int count = this._counter.IncreaseCount(); - + this._state!.Count = count; return count.ToString(); } } + public class CounterState + { + public int Count { get; set; } = 0; + } + + /// + /// The step that counts how many times it has been invoked. + /// + public sealed class SimpleCountStep : KernelProcessStep + { + public const string CountFunction = nameof(Count); + + private CounterState? _state; + + public override ValueTask ActivateAsync(KernelProcessStepState state) + { + this._state = state.State ?? new(); + Console.WriteLine($"Activating counter with value {this._state.Count}"); + return base.ActivateAsync(state); + } + + [KernelFunction] + public string Count() + { + this._state!.Count++; + Console.WriteLine($"[COUNTER-{this.StepName}] {this._state.Count}"); + return this._state!.Count.ToString(); + } + } + /// /// The step that counts how many times it has been invoked. /// @@ -46,11 +87,11 @@ public sealed class EvenNumberDetectorStep : KernelProcessStep public static class OutputEvents { /// - /// Event number event name + /// Even number event name /// public const string EvenNumber = nameof(EvenNumber); /// - /// Event number event name + /// Odd number event name /// public const string OddNumber = nameof(OddNumber); } @@ -67,11 +108,13 @@ public async Task DetectEvenNumberAsync(string numberString, KernelProcessStepCo var number = int.Parse(numberString); if (number % 2 == 0) { - await context.EmitEventAsync(OutputEvents.EvenNumber, numberString); + Console.WriteLine($"[EVEN_NUMBER-{this.StepName}] {number}"); + await context.EmitEventAsync(OutputEvents.EvenNumber, numberString, KernelProcessEventVisibility.Public); return; } - await context.EmitEventAsync(OutputEvents.OddNumber, numberString); + Console.WriteLine($"[ODD_NUMBER-{this.StepName}] {number}"); + await context.EmitEventAsync(OutputEvents.OddNumber, numberString, KernelProcessEventVisibility.Public); } } @@ -80,11 +123,82 @@ public async Task DetectEvenNumberAsync(string numberString, KernelProcessStepCo /// public sealed class EchoStep : KernelProcessStep { + /// + /// Output events emitted by + /// + public static class OutputEvents + { + /// + /// Echo message event name + /// + public const string EchoMessage = nameof(EchoMessage); + } + + [KernelFunction] + public async Task EchoAsync(KernelProcessStepContext context, string message) + { + Console.WriteLine($"[ECHO-{this.StepName}] {message}"); + await context.EmitEventAsync(OutputEvents.EchoMessage, data: message, KernelProcessEventVisibility.Public); + return message; + } + } + + /// + /// A step that echos its input. + /// + public sealed class DualEchoStep : KernelProcessStep + { + /// + /// Output events emitted by + /// + public static class OutputEvents + { + /// + /// Echo message event name + /// + public const string EchoMessage = nameof(EchoMessage); + } + [KernelFunction] - public string Echo(string message) + public async Task EchoAsync(KernelProcessStepContext context, string message1, string message2) { - Console.WriteLine($"[ECHO] {message}"); + var message = $"{message1} {message2}"; + Console.WriteLine($"[DUAL-ECHO-{this.StepName}] {message}"); + await context.EmitEventAsync(OutputEvents.EchoMessage, data: message, KernelProcessEventVisibility.Public); return message; } } + + /// + /// A step that echos its input. Delays input for a specified amount of time. + /// + public sealed class DelayedEchoStep : KernelProcessStep + { + public static class OutputEvents + { + public const string DelayedEcho = nameof(DelayedEcho); + } + + private readonly int _delayInMs = 10000; + + [KernelFunction] + public async Task EchoAsync(KernelProcessStepContext context, string message) + { + // Simulate a delay + Thread.Sleep(this._delayInMs); + Console.WriteLine($"[DELAYED_ECHO-{this.StepName}]: {message}"); + await context.EmitEventAsync(OutputEvents.DelayedEcho, data: message); + return message; + } + } + + public sealed class MergeStringsStep : KernelProcessStep + { + [KernelFunction] + public string MergeStrings(string str1, string str2, string str3) + { + Console.WriteLine($"[MERGE_STRINGS-{this.StepName}] {str1} {str2} {str3}"); + return string.Join(",", [str1, str2, str3]); + } + } }