more flow decorator tests

Author: Andrei Bratu

tests/integration/decorators.test.ts

@@ -65,4 +65,215 @@ describe("decorators", () => {
             throw error;
         }
     });
+
+    it("should create logs with proper tracing when using prompt in flow decorator", async () => {
+        // Track resources for cleanup
+        let flowId: string | null = null;
+        let promptId: string | null = null;
+
+        try {
+            // Create test flow and prompt paths
+            const flowPath = `${testSetup.sdkTestDir.path}/test_flow`;
+            const promptPath = `${testSetup.sdkTestDir.path}/test_prompt`;
+
+            // Create the prompt
+            const promptResponse = await testSetup.humanloopClient.prompts.upsert({
+                path: promptPath,
+                provider: "openai",
+                model: "gpt-4o-mini",
+                temperature: 0,
+            });
+            promptId = promptResponse.id;
+
+            // Define the flow callable function with the correct type signature
+            const flowCallable = async (question: {
+                question: string;
+            }): Promise<string> => {
+                const response = await testSetup.humanloopClient.prompts.call({
+                    path: promptPath,
+                    messages: [{ role: "user", content: question.question }],
+                    providerApiKeys: { openai: testSetup.openaiApiKey },
+                });
+
+                const output = response.logs?.[0]?.output;
+                expect(output).not.toBeNull();
+                return output || "";
+            };
+
+            // Apply the flow decorator
+            const myFlow = testSetup.humanloopClient.flow({
+                path: flowPath,
+                callable: flowCallable,
+            });
+
+            // Call the flow with the expected input format
+            const result = await myFlow({
+                question: "What is the capital of the France?",
+            });
+            expect(result?.toLowerCase()).toContain("paris");
+
+            // Wait for logs to be created
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+
+            // Verify prompt logs
+            const promptRetrieveResponse =
+                await testSetup.humanloopClient.files.retrieveByPath({
+                    path: promptPath,
+                });
+            expect(promptRetrieveResponse).not.toBeNull();
+            const promptLogsResponse = await testSetup.humanloopClient.logs.list({
+                fileId: promptRetrieveResponse.id,
+                page: 1,
+                size: 50,
+            });
+            expect(promptLogsResponse.data.length).toBe(1);
+            const promptLog = promptLogsResponse.data[0];
+
+            // Verify flow logs
+            const flowRetrieveResponse =
+                await testSetup.humanloopClient.files.retrieveByPath({
+                    path: flowPath,
+                });
+            expect(flowRetrieveResponse).not.toBeNull();
+            flowId = flowRetrieveResponse.id;
+            const flowLogsResponse = await testSetup.humanloopClient.logs.list({
+                fileId: flowRetrieveResponse.id,
+                page: 1,
+                size: 50,
+            });
+            expect(flowLogsResponse.data.length).toBe(1);
+            const flowLog = flowLogsResponse.data[0];
+
+            // Verify tracing between logs
+            expect(promptLog.traceParentId).toBe(flowLog.id);
+        } finally {
+            // Clean up resources
+            if (flowId) {
+                await testSetup.humanloopClient.flows.delete(flowId);
+            }
+            if (promptId) {
+                await testSetup.humanloopClient.prompts.delete(promptId);
+            }
+        }
+    });
+
+    it("should log exceptions when using the flow decorator", async () => {
+        // Track resources for cleanup
+        let flowId: string | null = null;
+
+        try {
+            // Create test flow path
+            const flowPath = `${testSetup.sdkTestDir.path}/test_flow_log_error`;
+
+            // Define a flow callable that throws an error
+            const flowCallable = async ({
+                question,
+            }: {
+                question: string;
+            }): Promise<string> => {
+                throw new Error("This is a test exception");
+            };
+
+            // Apply the flow decorator
+            const myFlow = testSetup.humanloopClient.flow({
+                path: flowPath,
+                callable: flowCallable,
+            });
+
+            // Call the flow and expect it to throw
+            try {
+                await myFlow({ question: "test" });
+                // If we get here, the test should fail
+                fail("Expected flow to throw an error but it didn't");
+            } catch (error) {
+                // Expected error
+                expect(error).toBeDefined();
+            }
+
+            // Wait for logs to be created
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+
+            // Verify flow logs
+            const flowRetrieveResponse =
+                await testSetup.humanloopClient.files.retrieveByPath({
+                    path: flowPath,
+                });
+            expect(flowRetrieveResponse).not.toBeNull();
+            flowId = flowRetrieveResponse.id;
+
+            const flowLogsResponse = await testSetup.humanloopClient.logs.list({
+                fileId: flowRetrieveResponse.id,
+                page: 1,
+                size: 50,
+            });
+            expect(flowLogsResponse.data.length).toBe(1);
+
+            const flowLog = flowLogsResponse.data[0];
+            expect(flowLog.error).not.toBeUndefined();
+            expect(flowLog.output).toBeUndefined();
+        } finally {
+            // Clean up resources
+            if (flowId) {
+                await testSetup.humanloopClient.flows.delete(flowId);
+            }
+        }
+    });
+
+    it("should populate outputMessage when flow returns chat message format", async () => {
+        // Track resources for cleanup
+        let flowId: string | null = null;
+
+        try {
+            // Create test flow path
+            const flowPath = `${testSetup.sdkTestDir.path}/test_flow_log_output_message`;
+
+            // Define a flow callable that returns a chat message format
+            const flowCallable = async ({ question }: { question: string }) => {
+                return {
+                    role: "user",
+                    content: question,
+                };
+            };
+
+            // Apply the flow decorator
+            const myFlow = testSetup.humanloopClient.flow({
+                path: flowPath,
+                callable: flowCallable,
+            });
+
+            // Call the flow and check the returned message
+            const result = await myFlow({
+                question: "What is the capital of the France?",
+            });
+            expect(result?.content.toLowerCase()).toContain("france");
+
+            // Wait for logs to be created
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+
+            // Verify flow logs
+            const flowRetrieveResponse =
+                await testSetup.humanloopClient.files.retrieveByPath({
+                    path: flowPath,
+                });
+            expect(flowRetrieveResponse).not.toBeNull();
+            flowId = flowRetrieveResponse.id;
+
+            const flowLogsResponse = await testSetup.humanloopClient.logs.list({
+                fileId: flowRetrieveResponse.id,
+                page: 1,
+                size: 50,
+            });
+            expect(flowLogsResponse.data.length).toBe(1);
+
+            const flowLog = flowLogsResponse.data[0];
+            expect(flowLog.outputMessage).not.toBeUndefined();
+            expect(flowLog.output).toBeUndefined();
+            expect(flowLog.error).toBeUndefined();
+        } finally {
+            // Clean up resources
+            if (flowId) {
+                await testSetup.humanloopClient.flows.delete(flowId);
+            }
+        }
+    });
 });